diff --git a/project.gyp b/project.gyp
index 2a7139a3..7ab41e42 100644
--- a/project.gyp
+++ b/project.gyp
@@ -29,7 +29,6 @@
         'src/compiler/generate_code/c_code.cc',
         'src/compiler/grammar.cc',
         'src/compiler/lex_table.cc',
-        'src/compiler/lexical_grammar.cc',
         'src/compiler/parse_table.cc',
         'src/compiler/prepare_grammar/expand_repeats.cc',
         'src/compiler/prepare_grammar/expand_tokens.cc',
@@ -39,7 +38,6 @@
         'src/compiler/prepare_grammar/parse_regex.cc',
         'src/compiler/prepare_grammar/prepare_grammar.cc',
         'src/compiler/prepare_grammar/token_description.cc',
-        'src/compiler/syntax_grammar.cc',
         'src/compiler/rule.cc',
         'src/compiler/rules/blank.cc',
         'src/compiler/rules/built_in_symbols.cc',
diff --git a/spec/compiler/build_tables/build_parse_table_spec.cc b/spec/compiler/build_tables/build_parse_table_spec.cc
index 391b283f..7a1fc17d 100644
--- a/spec/compiler/build_tables/build_parse_table_spec.cc
+++ b/spec/compiler/build_tables/build_parse_table_spec.cc
@@ -1,8 +1,7 @@
 #include "compiler/compiler_spec_helper.h"
 #include "compiler/build_tables/build_parse_table.h"
 #include "compiler/parse_table.h"
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/built_in_symbols.h"
 
 using namespace rules;
@@ -12,15 +11,35 @@ START_TEST
 
 describe("build_parse_table", []() {
   SyntaxGrammar parse_grammar{{
-    { "rule0", choice({ i_sym(1), i_sym(2) }) },
-    { "rule1", i_token(0) },
-    { "rule2", i_token(1) },
-  }, {}, { Symbol(2, SymbolOptionToken) }, {}};
+    {
+      "rule0",
+      choice({ i_sym(1), i_sym(2) }),
+      RuleEntryTypeNamed
+    },
+    {
+      "rule1",
+      i_token(0),
+      RuleEntryTypeNamed
+    },
+    {
+      "rule2",
+      i_token(1),
+      RuleEntryTypeNamed
+    },
+  }, { Symbol(2, true) }, {}};
 
   LexicalGrammar lex_grammar{{
-    { "token0", pattern("[a-c]") },
-    { "token1", pattern("[b-d]") },
-  }, {}, {}};
+    {
+      "token0",
+      pattern("[a-c]"),
+      RuleEntryTypeNamed
+    },
+    {
+      "token1",
+      pattern("[b-d]"),
+      RuleEntryTypeNamed
+    },
+  }, {}};
 
   it("first looks for the start rule and its item set closure", [&]() {
     auto result = build_parse_table(parse_grammar, lex_grammar);
@@ -32,11 +51,11 @@ describe("build_parse_table", []() {
       // expanded from the item set closure of the start item
       { Symbol(1), {ParseAction::Shift(2, { 0 })} },
       { Symbol(2), {ParseAction::Shift(2, { 0 })} },
-      { Symbol(0, SymbolOptionToken), {ParseAction::Shift(3, { 0 })} },
-      { Symbol(1, SymbolOptionToken), {ParseAction::Shift(4, { 0 })} },
+      { Symbol(0, true), {ParseAction::Shift(3, { 0 })} },
+      { Symbol(1, true), {ParseAction::Shift(4, { 0 })} },
 
       // for the ubiquitous_token 'token2'
-      { Symbol(2, SymbolOptionToken), {ParseAction::ShiftExtra()} },
+      { Symbol(2, true), {ParseAction::ShiftExtra()} },
     })));
   });
 
@@ -52,7 +71,7 @@ describe("build_parse_table", []() {
       { END_OF_INPUT(), {ParseAction::Accept()} },
 
       // for the ubiquitous_token 'token2'
-      { Symbol(2, SymbolOptionToken), {ParseAction::ShiftExtra()} },
+      { Symbol(2, true), {ParseAction::ShiftExtra()} },
     })));
   });
 
@@ -63,7 +82,7 @@ describe("build_parse_table", []() {
       { END_OF_INPUT(), {ParseAction::Reduce(Symbol(0), 1, 0, AssociativityLeft, 0)} },
 
       // for the ubiquitous_token 'token2'
-      { Symbol(2, SymbolOptionToken), {ParseAction::ShiftExtra()} },
+      { Symbol(2, true), {ParseAction::ShiftExtra()} },
     })));
   });
 });
diff --git a/spec/compiler/build_tables/first_symbols_spec.cc b/spec/compiler/build_tables/first_symbols_spec.cc
index 79ce7e8d..37387f59 100644
--- a/spec/compiler/build_tables/first_symbols_spec.cc
+++ b/spec/compiler/build_tables/first_symbols_spec.cc
@@ -1,5 +1,5 @@
 #include "compiler/compiler_spec_helper.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/build_tables/first_symbols.h"
 #include "compiler/rules/metadata.h"
 
@@ -16,7 +16,7 @@ describe("first_symbols", []() {
       auto rule = seq({ i_token(0), i_token(1) });
 
       AssertThat(first_symbols(rule, null_grammar), Equals(set<Symbol>({
-        Symbol(0, SymbolOptionToken),
+        Symbol(0, true),
       })));
     });
 
@@ -28,8 +28,8 @@ describe("first_symbols", []() {
         i_token(1) });
 
       AssertThat(first_symbols(rule, null_grammar), Equals(set<Symbol>({
-        Symbol(0, SymbolOptionToken),
-        Symbol(1, SymbolOptionToken)
+        Symbol(0, true),
+        Symbol(1, true)
       })));
     });
 
@@ -41,16 +41,21 @@ describe("first_symbols", []() {
         i_sym(0) });
 
       SyntaxGrammar grammar{{
-        { "rule0", seq({
-          i_token(2),
-          i_token(3),
-          i_token(4) }) }
-      }, {}, {}, {}};
+        {
+          "rule0",
+          seq({
+            i_token(2),
+            i_token(3),
+            i_token(4),
+          }),
+          RuleEntryTypeNamed
+        }
+      }, {}, {}};
 
       AssertThat(first_symbols(rule, grammar), Equals(set<Symbol>({
         Symbol(0),
-        Symbol(0, SymbolOptionToken),
-        Symbol(2, SymbolOptionToken),
+        Symbol(0, true),
+        Symbol(2, true),
       })));
     });
 
@@ -60,15 +65,20 @@ describe("first_symbols", []() {
         i_token(1) });
 
       SyntaxGrammar grammar{{
-        { "rule0", choice({
-          i_token(0),
-          blank() }) }
-      }, {}, {}, {}};
+        {
+          "rule0",
+          choice({
+            i_token(0),
+            blank(),
+          }),
+          RuleEntryTypeNamed
+        },
+      }, {}, {}};
 
       AssertThat(first_symbols(rule, grammar), Equals(set<Symbol>({
         Symbol(0),
-        Symbol(0, SymbolOptionToken),
-        Symbol(1, SymbolOptionToken),
+        Symbol(0, true),
+        Symbol(1, true),
       })));
     });
   });
@@ -76,17 +86,21 @@ describe("first_symbols", []() {
   describe("when there are left-recursive rules", [&]() {
     it("terminates", [&]() {
       SyntaxGrammar grammar{{
-        { "rule0", choice({
-          seq({ i_sym(0), i_token(10) }),
-          i_token(11),
-        }) },
-      }, {}, {}, {}};
+        {
+          "rule0",
+          choice({
+            seq({ i_sym(0), i_token(10) }),
+            i_token(11),
+          }),
+          RuleEntryTypeNamed
+        },
+      }, {}, {}};
 
       auto rule = i_sym(0);
 
       AssertThat(first_symbols(rule, grammar), Equals(set<Symbol>({
         Symbol(0),
-        Symbol(11, SymbolOptionToken)
+        Symbol(11, true)
       })));
     });
   });
@@ -95,7 +109,7 @@ describe("first_symbols", []() {
     auto rule = make_shared<Metadata>(i_token(3), map<rules::MetadataKey, int>());
 
     AssertThat(first_symbols(rule, null_grammar), Equals(set<Symbol>({
-      Symbol(3, SymbolOptionToken),
+      Symbol(3, true),
     })));
   });
 });
diff --git a/spec/compiler/build_tables/item_set_closure_spec.cc b/spec/compiler/build_tables/item_set_closure_spec.cc
index d7ef41e2..50e9b572 100644
--- a/spec/compiler/build_tables/item_set_closure_spec.cc
+++ b/spec/compiler/build_tables/item_set_closure_spec.cc
@@ -1,5 +1,5 @@
 #include "compiler/compiler_spec_helper.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/build_tables/item_set_closure.h"
 #include "compiler/build_tables/item_set_transitions.h"
 
@@ -10,29 +10,39 @@ START_TEST
 
 describe("item_set_closure", []() {
   SyntaxGrammar grammar{{
-    { "E", seq({
-      i_sym(1),
-      i_token(11) }) },
-    { "T", seq({
-      i_token(12),
-      i_token(13) }) },
-  }, {}, {}, {}};
+    {
+      "E",
+      seq({
+        i_sym(1),
+        i_token(11),
+      }),
+      RuleEntryTypeNamed,
+    },
+    {
+      "T",
+      seq({
+        i_token(12),
+        i_token(13),
+      }),
+      RuleEntryTypeNamed,
+    },
+  }, {}, {}};
 
   it("adds items at the beginnings of referenced rules", [&]() {
     ParseItemSet item_set = item_set_closure(
-      ParseItem(Symbol(0), grammar.rule(Symbol(0)), {}),
-      set<Symbol>({ Symbol(10, SymbolOptionToken) }),
+      ParseItem(Symbol(0), grammar.rules[0].rule, {}),
+      set<Symbol>({ Symbol(10, true) }),
       grammar
     );
 
     AssertThat(item_set, Equals(ParseItemSet({
       {
-        ParseItem(Symbol(1), grammar.rule(Symbol(1)), {}),
-        set<Symbol>({ Symbol(11, SymbolOptionToken) }),
+        ParseItem(Symbol(1), grammar.rules[1].rule, {}),
+        set<Symbol>({ Symbol(11, true) }),
       },
       {
-        ParseItem(Symbol(0), grammar.rule(Symbol(0)), {}),
-        set<Symbol>({ Symbol(10, SymbolOptionToken) }),
+        ParseItem(Symbol(0), grammar.rules[0].rule, {}),
+        set<Symbol>({ Symbol(10, true) }),
       },
     })));
   });
diff --git a/spec/compiler/build_tables/item_set_transitions_spec.cc b/spec/compiler/build_tables/item_set_transitions_spec.cc
index f1c0684b..b5bdf1be 100644
--- a/spec/compiler/build_tables/item_set_transitions_spec.cc
+++ b/spec/compiler/build_tables/item_set_transitions_spec.cc
@@ -1,6 +1,6 @@
 #include "compiler/compiler_spec_helper.h"
 #include "compiler/build_tables/item_set_transitions.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/helpers/rule_helpers.h"
 
 using namespace rules;
@@ -43,29 +43,37 @@ describe("char_transitions(LexItemSet)", []() {
 
 describe("sym_transitions(ParseItemSet, SyntaxGrammar)", [&]() {
   SyntaxGrammar grammar{{
-    { "A", blank() },
-    { "B", i_token(21) },
-  }, {}, {}, {}};
+    {
+      "A",
+      blank(),
+      RuleEntryTypeNamed
+    },
+    {
+      "B",
+      i_token(21),
+      RuleEntryTypeNamed
+    },
+  }, {}, {}};
 
   it("computes the closure of the new item sets", [&]() {
     ParseItemSet set1({
       {
         ParseItem(Symbol(0), seq({ i_token(22), i_sym(1) }), { Symbol(101) }),
-        set<Symbol>({ Symbol(23, SymbolOptionToken) })
+        set<Symbol>({ Symbol(23, true) })
       },
     });
 
     AssertThat(sym_transitions(set1, grammar), Equals(map<Symbol, ParseItemSet>({
       {
-        Symbol(22, SymbolOptionToken),
+        Symbol(22, true),
         ParseItemSet({
           {
             ParseItem(Symbol(0), i_sym(1), { Symbol(101), Symbol(22) }),
-            set<Symbol>({ Symbol(23, SymbolOptionToken) }),
+            set<Symbol>({ Symbol(23, true) }),
           },
           {
             ParseItem(Symbol(1), i_token(21), {}),
-            set<Symbol>({ Symbol(23, SymbolOptionToken) })
+            set<Symbol>({ Symbol(23, true) })
           },
         })
       },
diff --git a/spec/compiler/build_tables/lex_conflict_manager_spec.cc b/spec/compiler/build_tables/lex_conflict_manager_spec.cc
index 0f07622b..44e9814b 100644
--- a/spec/compiler/build_tables/lex_conflict_manager_spec.cc
+++ b/spec/compiler/build_tables/lex_conflict_manager_spec.cc
@@ -2,7 +2,7 @@
 #include "compiler/rules/built_in_symbols.h"
 #include "compiler/parse_table.h"
 #include "compiler/build_tables/lex_conflict_manager.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 using namespace rules;
 using namespace build_tables;
@@ -11,16 +11,24 @@ START_TEST
 
 describe("LexConflictManager", []() {
   LexicalGrammar lexical_grammar{{
-    { "other_token", pattern("[a-b]") },
-    { "lookahead_token", pattern("[c-d]") },
-  }, {}, {}};
+    {
+      "other_token",
+      pattern("[a-b]"),
+      RuleEntryTypeNamed
+    },
+    {
+      "lookahead_token",
+      pattern("[c-d]"),
+      RuleEntryTypeNamed
+    },
+  }, {}};
 
   LexConflictManager conflict_manager(lexical_grammar);
 
   bool update;
-  Symbol sym1(0, SymbolOptionToken);
-  Symbol sym2(1, SymbolOptionToken);
-  Symbol sym3(2, SymbolOptionToken);
+  Symbol sym1(0, true);
+  Symbol sym2(1, true);
+  Symbol sym3(2, true);
 
   it("favors non-errors over lexical errors", [&]() {
     update = conflict_manager.resolve(LexAction::Advance(2, {0}), LexAction::Error());
diff --git a/spec/compiler/build_tables/parse_conflict_manager_spec.cc b/spec/compiler/build_tables/parse_conflict_manager_spec.cc
index 924c67d7..e4287e46 100644
--- a/spec/compiler/build_tables/parse_conflict_manager_spec.cc
+++ b/spec/compiler/build_tables/parse_conflict_manager_spec.cc
@@ -2,7 +2,7 @@
 #include "compiler/rules/built_in_symbols.h"
 #include "compiler/parse_table.h"
 #include "compiler/build_tables/parse_conflict_manager.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 using namespace rules;
 using namespace build_tables;
@@ -11,17 +11,37 @@ START_TEST
 
 describe("ParseConflictManager", []() {
   SyntaxGrammar syntax_grammar{{
-    { "in_progress_rule1", i_token(0) },
-    { "in_progress_rule2", i_token(0) },
-    { "reduced_rule", i_token(0) },
-    { "other_rule1", i_token(0) },
-    { "other_rule2", i_token(0) },
-  }, {}, { Symbol(2, SymbolOptionToken) }, {}};
+    {
+      "in_progress_rule1",
+      i_token(0),
+      RuleEntryTypeNamed,
+    },
+    {
+      "in_progress_rule2",
+      i_token(0),
+      RuleEntryTypeNamed,
+    },
+    {
+      "reduced_rule",
+      i_token(0),
+      RuleEntryTypeNamed,
+    },
+    {
+      "other_rule1",
+      i_token(0),
+      RuleEntryTypeNamed,
+    },
+    {
+      "other_rule2",
+      i_token(0),
+      RuleEntryTypeNamed,
+    },
+  }, { Symbol(2, true) }, {}};
 
   pair<bool, ConflictType> result;
   Symbol sym1(0);
   Symbol sym2(1);
-  Symbol lookahead_sym(1, SymbolOptionToken);
+  Symbol lookahead_sym(1, true);
   ParseConflictManager *conflict_manager;
 
   before_each([&]() {
diff --git a/spec/compiler/build_tables/rule_can_be_blank_spec.cc b/spec/compiler/build_tables/rule_can_be_blank_spec.cc
index 7b2c8fdf..f29d5fd9 100644
--- a/spec/compiler/build_tables/rule_can_be_blank_spec.cc
+++ b/spec/compiler/build_tables/rule_can_be_blank_spec.cc
@@ -1,7 +1,7 @@
 #include "compiler/compiler_spec_helper.h"
 #include "compiler/build_tables/rule_can_be_blank.h"
 #include "compiler/rules/metadata.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 using namespace rules;
 using build_tables::rule_can_be_blank;
@@ -57,13 +57,23 @@ describe("rule_can_be_blank", [&]() {
 
   describe("checking recursively (by expanding non-terminals)", [&]() {
     SyntaxGrammar grammar{{
-      { "A", choice({
-        seq({ i_sym(0), i_token(11) }),
-        blank() }) },
-      { "B", choice({
-        seq({ i_sym(1), i_token(12) }),
-        i_token(13) }) },
-    }, {}, {}, {}};
+      {
+        "A",
+        choice({
+          seq({ i_sym(0), i_token(11) }),
+          blank()
+        }),
+        RuleEntryTypeNamed,
+      },
+      {
+        "B",
+        choice({
+          seq({ i_sym(1), i_token(12) }),
+          i_token(13)
+        }),
+        RuleEntryTypeNamed,
+      },
+    }, {}, {}};
 
     it("terminates for left-recursive rules that can be blank", [&]() {
       rule = i_sym(0);
diff --git a/spec/compiler/helpers/containers.h b/spec/compiler/helpers/containers.h
index 86c6069b..29896d80 100644
--- a/spec/compiler/helpers/containers.h
+++ b/spec/compiler/helpers/containers.h
@@ -48,6 +48,20 @@ class rule_list : public vector<pair<string, rule_ptr>> {
       vector<pair<string, rule_ptr>>(list) {}
 };
 
+template<typename T>
+class eq_vector : public vector<T> {
+ public:
+  bool operator==(const vector<T> &other) const {
+    if (this->size() != other.size()) return false;
+    for (size_t i = 0; i < this->size(); i++)
+      if (!(this->operator[](i) == other[i]))
+        return false;
+    return true;
+  }
+
+  eq_vector(const initializer_list<T> &list) : vector<T>(list) {}
+};
+
 class rule_vector : public vector<rule_ptr> {
  public:
   bool operator==(const vector<rule_ptr> &other) const {
diff --git a/spec/compiler/helpers/rule_helpers.cc b/spec/compiler/helpers/rule_helpers.cc
index 042793eb..039cdf7b 100644
--- a/spec/compiler/helpers/rule_helpers.cc
+++ b/spec/compiler/helpers/rule_helpers.cc
@@ -6,43 +6,41 @@ namespace tree_sitter {
   using std::make_shared;
   using std::set;
   using std::map;
+  using std::ostream;
+  using std::string;
+  using std::to_string;
 
-  namespace rules {
-    rule_ptr character(const set<uint32_t> &ranges) {
-      return character(ranges, true);
-    }
+  rule_ptr character(const set<uint32_t> &ranges) {
+    return character(ranges, true);
+  }
 
-    rule_ptr character(const set<uint32_t> &chars, bool sign) {
-      CharacterSet result;
-      if (sign) {
-        for (uint32_t c : chars)
-          result.include(c);
-      } else {
-        result.include_all();
-        for (uint32_t c : chars)
-          result.exclude(c);
-      }
-      return result.copy();
+  rule_ptr character(const set<uint32_t> &chars, bool sign) {
+    rules::CharacterSet result;
+    if (sign) {
+      for (uint32_t c : chars)
+        result.include(c);
+    } else {
+      result.include_all();
+      for (uint32_t c : chars)
+        result.exclude(c);
     }
+    return result.copy();
+  }
 
-    rule_ptr i_sym(size_t index) {
-      return make_shared<rules::Symbol>(index);
-    }
+  rule_ptr i_sym(size_t index) {
+    return make_shared<rules::Symbol>(index);
+  }
 
-    rule_ptr i_aux_sym(size_t index) {
-      return make_shared<rules::Symbol>(index, SymbolOptionAuxiliary);
-    }
+  rule_ptr i_token(size_t index) {
+    return make_shared<rules::Symbol>(index, true);
+  }
 
-    rule_ptr i_token(size_t index) {
-      return make_shared<rules::Symbol>(index, SymbolOptionToken);
-    }
+  rule_ptr metadata(rule_ptr rule, map<rules::MetadataKey, int> values) {
+    return make_shared<rules::Metadata>(rule, values);
+  }
 
-    rule_ptr i_aux_token(size_t index) {
-      return make_shared<rules::Symbol>(index, SymbolOption(SymbolOptionAuxiliary|SymbolOptionToken));
-    }
-
-    rule_ptr metadata(rule_ptr rule, map<MetadataKey, int> values) {
-      return make_shared<Metadata>(rule, values);
-    }
+  bool operator==(const RuleEntry &left, const RuleEntry &right) {
+    return left.name == right.name && left.rule->operator==(*right.rule) &&
+      left.type == right.type;
   }
 }
diff --git a/spec/compiler/helpers/rule_helpers.h b/spec/compiler/helpers/rule_helpers.h
index a18318cb..af2775ee 100644
--- a/spec/compiler/helpers/rule_helpers.h
+++ b/spec/compiler/helpers/rule_helpers.h
@@ -4,17 +4,16 @@
 #include "tree_sitter/compiler.h"
 #include "compiler/rules/character_set.h"
 #include "compiler/rules/metadata.h"
+#include "compiler/prepared_grammar.h"
 
 namespace tree_sitter {
-  namespace rules {
-    rule_ptr metadata(rule_ptr, std::map<MetadataKey, int>);
-    rule_ptr character(const std::set<uint32_t> &);
-    rule_ptr character(const std::set<uint32_t> &, bool sign);
-    rule_ptr i_sym(size_t index);
-    rule_ptr i_aux_sym(size_t index);
-    rule_ptr i_token(size_t index);
-    rule_ptr i_aux_token(size_t index);
-  }
+  rule_ptr metadata(rule_ptr, std::map<rules::MetadataKey, int>);
+  rule_ptr character(const std::set<uint32_t> &);
+  rule_ptr character(const std::set<uint32_t> &, bool sign);
+  rule_ptr i_sym(size_t index);
+  rule_ptr i_token(size_t index);
+
+  bool operator==(const RuleEntry &left, const RuleEntry &right);
 }
 
 #endif
diff --git a/spec/compiler/helpers/stream_methods.h b/spec/compiler/helpers/stream_methods.h
index 5d3fc663..54c39fec 100644
--- a/spec/compiler/helpers/stream_methods.h
+++ b/spec/compiler/helpers/stream_methods.h
@@ -7,6 +7,7 @@
 #include <map>
 #include <unordered_set>
 #include <vector>
+#include "compiler/prepared_grammar.h"
 
 using std::cout;
 
@@ -83,4 +84,16 @@ inline std::ostream& operator<<(std::ostream &stream, const std::pair<T1, T2> &p
 
 }  // namespace std
 
+namespace tree_sitter {
+
+using std::ostream;
+using std::string;
+using std::to_string;
+
+inline ostream &operator<<(ostream &stream, const RuleEntry &entry) {
+  return stream << string("{") << entry.name << string(", ") << entry.rule << string(", ") << to_string(entry.type) << string("}");
+}
+
+}
+
 #endif
diff --git a/spec/compiler/prepare_grammar/expand_repeats_spec.cc b/spec/compiler/prepare_grammar/expand_repeats_spec.cc
index 91bb8e9b..2ed0b443 100644
--- a/spec/compiler/prepare_grammar/expand_repeats_spec.cc
+++ b/spec/compiler/prepare_grammar/expand_repeats_spec.cc
@@ -1,5 +1,5 @@
 #include "compiler/compiler_spec_helper.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/prepare_grammar/expand_repeats.h"
 #include "compiler/helpers/containers.h"
 
@@ -11,131 +11,223 @@ using prepare_grammar::expand_repeats;
 describe("expand_repeats", []() {
   it("replaces repeat rules with pairs of recursive rules", [&]() {
     SyntaxGrammar grammar{{
-      { "rule0", repeat(i_token(0)) },
-    }, {}, {}, {}};
+      {
+        "rule0",
+        repeat(i_token(0)),
+        RuleEntryTypeNamed,
+      },
+    }, {}, {}};
 
     auto match = expand_repeats(grammar);
 
-    AssertThat(match.rules, Equals(rule_list({
-      { "rule0", choice({ i_aux_sym(0), blank() }) },
-    })));
-
-    AssertThat(match.aux_rules, Equals(rule_list({
-      { "rule0_repeat0", seq({
-        i_token(0),
-        choice({ i_aux_sym(0), blank() }) }) },
+    AssertThat(match.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule0",
+        choice({ i_sym(1), blank() }),
+        RuleEntryTypeNamed,
+      },
+      {
+        "rule0_repeat1",
+        seq({
+          i_token(0),
+          choice({ i_sym(1), blank() })
+        }),
+        RuleEntryTypeHidden
+      },
     })));
   });
 
   it("replaces repeats inside of sequences", [&]() {
     SyntaxGrammar grammar{{
-      { "rule0", seq({
-        i_token(10),
-        repeat(i_token(11)) }) },
-    }, {}, {}, {}};
+      {
+        "rule0",
+        seq({
+          i_token(10),
+          repeat(i_token(11)),
+        }),
+        RuleEntryTypeNamed,
+      },
+    }, {}, {}};
 
     auto match = expand_repeats(grammar);
 
-    AssertThat(match.rules, Equals(rule_list({
-      { "rule0", seq({
-        i_token(10),
-        choice({ i_aux_sym(0), blank() }) }) },
-    })));
-
-    AssertThat(match.aux_rules, Equals(rule_list({
-      { "rule0_repeat0", seq({
-        i_token(11),
-        choice({ i_aux_sym(0), blank() }) }) },
+    AssertThat(match.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule0",
+        seq({
+          i_token(10),
+          choice({ i_sym(1), blank() })
+        }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule0_repeat1",
+        seq({
+          i_token(11),
+          choice({ i_sym(1), blank() })
+        }),
+        RuleEntryTypeHidden
+      },
     })));
   });
 
   it("replaces repeats inside of choices", [&]() {
     SyntaxGrammar grammar{{
-      { "rule0", choice({ i_token(10), repeat(i_token(11)) }) },
-    }, {}, {}, {}};
+      {
+        "rule0",
+        choice({ i_token(10), repeat(i_token(11)) }),
+        RuleEntryTypeNamed
+      },
+    }, {}, {}};
 
     auto match = expand_repeats(grammar);
 
-    AssertThat(match.rules, Equals(rule_list({
-      { "rule0", choice({ i_token(10), i_aux_sym(0), blank() }) },
-    })));
-
-    AssertThat(match.aux_rules, Equals(rule_list({
-      { "rule0_repeat0", seq({
-        i_token(11),
-        choice({ i_aux_sym(0), blank() }) }) },
+    AssertThat(match.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule0",
+        choice({ i_token(10), i_sym(1), blank() }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule0_repeat1",
+        seq({
+          i_token(11),
+          choice({ i_sym(1), blank() }),
+        }),
+        RuleEntryTypeHidden
+      },
     })));
   });
 
   it("does not create redundant auxiliary rules", [&]() {
     SyntaxGrammar grammar{{
-      { "rule0", choice({
-        seq({ i_token(1), repeat(i_token(4)) }),
-        seq({ i_token(2), repeat(i_token(4)) }) }) },
-      { "rule1", seq({ i_token(3), repeat(i_token(4)) }) },
-    }, {}, {}, {}};
+      {
+        "rule0",
+        choice({
+          seq({ i_token(1), repeat(i_token(4)) }),
+          seq({ i_token(2), repeat(i_token(4)) }),
+        }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule1",
+        seq({ i_token(3), repeat(i_token(4)) }),
+        RuleEntryTypeNamed
+      },
+    }, {}, {}};
 
     auto match = expand_repeats(grammar);
 
-    AssertThat(match.rules, Equals(rule_list({
-      { "rule0", choice({
-        seq({ i_token(1), choice({ i_aux_sym(0), blank() }) }),
-        seq({ i_token(2), choice({ i_aux_sym(0), blank() }) }) }) },
-      { "rule1", seq({ i_token(3), choice({ i_aux_sym(0), blank() }) }) },
-    })));
-
-    AssertThat(match.aux_rules, Equals(rule_list({
-      { "rule0_repeat0", seq({
-        i_token(4),
-        choice({ i_aux_sym(0), blank() }) }) },
+    AssertThat(match.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule0",
+        choice({
+          seq({ i_token(1), choice({ i_sym(2), blank() }) }),
+          seq({ i_token(2), choice({ i_sym(2), blank() }) }),
+        }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule1",
+        seq({ i_token(3), choice({ i_sym(2), blank() }) }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule0_repeat1",
+        seq({
+          i_token(4),
+          choice({ i_sym(2), blank() }),
+        }),
+        RuleEntryTypeHidden
+      },
     })));
   });
 
   it("can replace multiple repeats in the same rule", [&]() {
     SyntaxGrammar grammar{{
-      { "rule0", seq({
-        repeat(i_token(10)),
-        repeat(i_token(11)) }) },
-    }, {}, {}, {}};
+      {
+        "rule0",
+        seq({
+          repeat(i_token(10)),
+          repeat(i_token(11)),
+        }),
+        RuleEntryTypeNamed
+      },
+    }, {}, {}};
 
     auto match = expand_repeats(grammar);
 
-    AssertThat(match.rules, Equals(rule_list({
-      { "rule0", seq({
-        choice({ i_aux_sym(0), blank() }),
-        choice({ i_aux_sym(1), blank() }) }) },
-    })));
-
-    AssertThat(match.aux_rules, Equals(rule_list({
-      { "rule0_repeat0", seq({
-        i_token(10),
-        choice({ i_aux_sym(0), blank() }) }) },
-      { "rule0_repeat1", seq({
-        i_token(11),
-        choice({ i_aux_sym(1), blank() }) }) },
+    AssertThat(match.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule0",
+        seq({
+          choice({ i_sym(1), blank() }),
+          choice({ i_sym(2), blank() }),
+        }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule0_repeat1",
+        seq({
+          i_token(10),
+          choice({ i_sym(1), blank() }),
+        }),
+        RuleEntryTypeHidden
+      },
+      {
+        "rule0_repeat2",
+        seq({
+          i_token(11),
+          choice({ i_sym(2), blank() }),
+        }),
+        RuleEntryTypeHidden
+      },
     })));
   });
 
   it("can replace repeats in multiple rules", [&]() {
     SyntaxGrammar grammar{{
-      { "rule0", repeat(i_token(10)) },
-      { "rule1", repeat(i_token(11)) },
-    }, {}, {}, {}};
+      {
+        "rule0",
+        repeat(i_token(10)),
+        RuleEntryTypeNamed,
+      },
+      {
+        "rule1",
+        repeat(i_token(11)),
+        RuleEntryTypeNamed,
+      },
+    }, {}, {}};
 
     auto match = expand_repeats(grammar);
 
-    AssertThat(match.rules, Equals(rule_list({
-      { "rule0", choice({ i_aux_sym(0), blank() }) },
-      { "rule1", choice({ i_aux_sym(1), blank() }) },
-    })));
-
-    AssertThat(match.aux_rules, Equals(rule_list({
-      { "rule0_repeat0", seq({
-        i_token(10),
-        choice({ i_aux_sym(0), blank() }) }) },
-      { "rule1_repeat0", seq({
-        i_token(11),
-        choice({ i_aux_sym(1), blank() }) }) },
+    AssertThat(match.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule0",
+        choice({ i_sym(2), blank() }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule1",
+        choice({ i_sym(3), blank() }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule0_repeat1",
+        seq({
+          i_token(10),
+          choice({ i_sym(2), blank() }),
+        }),
+        RuleEntryTypeHidden
+      },
+      {
+        "rule1_repeat1",
+        seq({
+          i_token(11),
+          choice({ i_sym(3), blank() })
+        }),
+        RuleEntryTypeHidden
+      },
     })));
   });
 });
diff --git a/spec/compiler/prepare_grammar/expand_tokens_spec.cc b/spec/compiler/prepare_grammar/expand_tokens_spec.cc
index 91746df5..09bdf87e 100644
--- a/spec/compiler/prepare_grammar/expand_tokens_spec.cc
+++ b/spec/compiler/prepare_grammar/expand_tokens_spec.cc
@@ -1,5 +1,5 @@
 #include "compiler/compiler_spec_helper.h"
-#include "compiler/lexical_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/helpers/containers.h"
 #include "compiler/prepare_grammar/expand_tokens.h"
 
@@ -12,36 +12,64 @@ describe("expand_tokens", []() {
   describe("string rules", [&]() {
     it("replaces strings with sequences of character sets", [&]() {
       LexicalGrammar grammar{{
-        { "rule_A", seq({
-          i_sym(10),
-          str("xyz"),
-          i_sym(11) }) },
-      }, {}, {}};
+        {
+          "rule_A",
+          seq({
+            i_sym(10),
+            str("xyz"),
+            i_sym(11),
+          }),
+          RuleEntryTypeNamed
+        },
+      }, {}};
 
       auto result = expand_tokens(grammar);
 
       AssertThat(result.second, Equals((const GrammarError *)nullptr));
-      AssertThat(result.first.rules, Equals(rule_list({
-        { "rule_A", seq({
-          i_sym(10),
-          token(prec(1, seq({ character({ 'x' }), character({ 'y' }), character({ 'z' }) }))),
-          i_sym(11) }) },
+      AssertThat(result.first.rules, Equals(eq_vector<RuleEntry>({
+        {
+          "rule_A",
+          seq({
+            i_sym(10),
+            metadata(seq({
+              character({ 'x' }),
+              character({ 'y' }),
+              character({ 'z' }),
+            }), {
+              {PRECEDENCE, 1},
+              {IS_TOKEN, 1},
+            }),
+            i_sym(11),
+          }),
+          RuleEntryTypeNamed
+        },
       })));
     });
 
     it("handles strings containing non-ASCII UTF8 characters", [&]() {
       LexicalGrammar grammar{{
-        // α β
-        { "rule_A", str("\u03B1 \u03B2") },
-      }, {}, {}};
+        {
+          "rule_A",
+          str("\u03B1 \u03B2"), // α β
+          RuleEntryTypeNamed
+        },
+      }, {}};
 
       auto result = expand_tokens(grammar);
 
-      AssertThat(result.first.rules, Equals(rule_list({
-        { "rule_A", token(prec(1, seq({
-          character({ 945 }),
-          character({ ' ' }),
-          character({ 946 }) }))) }
+      AssertThat(result.first.rules, Equals(eq_vector<RuleEntry>({
+        {
+          "rule_A",
+          metadata(seq({
+            character({ 945 }),
+            character({ ' ' }),
+            character({ 946 }),
+          }), {
+            {PRECEDENCE, 1},
+            {IS_TOKEN, 1},
+          }),
+          RuleEntryTypeNamed
+        }
       })));
     });
   });
@@ -49,43 +77,65 @@ describe("expand_tokens", []() {
   describe("regexp rules", [&]() {
     it("replaces regexps with the equivalent rule tree", [&]() {
       LexicalGrammar grammar{{
-        { "rule_A", seq({
-          i_sym(10),
-          pattern("x*"),
-          i_sym(11) }) },
-      }, {}, {}};
+        {
+          "rule_A",
+          seq({
+            i_sym(10),
+            pattern("x*"),
+            i_sym(11),
+          }),
+          RuleEntryTypeNamed
+        },
+      }, {}};
 
       auto result = expand_tokens(grammar);
 
       AssertThat(result.second, Equals((const GrammarError *)nullptr));
-      AssertThat(result.first.rules, Equals(rule_list({
-        { "rule_A", seq({
-          i_sym(10),
-          repeat(character({ 'x' })),
-          i_sym(11) }) },
+      AssertThat(result.first.rules, Equals(eq_vector<RuleEntry>({
+        {
+          "rule_A",
+          seq({
+            i_sym(10),
+            repeat(character({ 'x' })),
+            i_sym(11),
+          }),
+          RuleEntryTypeNamed
+        },
       })));
     });
 
     it("handles regexps containing non-ASCII UTF8 characters", [&]() {
       LexicalGrammar grammar{{
-        // [^α-δ]
-        { "rule_A", pattern("[^\u03B1-\u03B4]*") },
-      }, {}, {}};
+        {
+          "rule_A",
+          pattern("[^\u03B1-\u03B4]*"), // [^α-δ]
+          RuleEntryTypeNamed
+        },
+      }, {}};
 
       auto result = expand_tokens(grammar);
 
-      AssertThat(result.first.rules, Equals(rule_list({
-        { "rule_A", repeat(character({ 945, 946, 947, 948 }, false)) }
+      AssertThat(result.first.rules, Equals(eq_vector<RuleEntry>({
+        {
+          "rule_A",
+          repeat(character({ 945, 946, 947, 948 }, false)),
+          RuleEntryTypeNamed
+        }
       })));
     });
 
     it("returns an error when the grammar contains an invalid regex", [&]() {
       LexicalGrammar grammar{{
-        { "rule_A", seq({
-          pattern("("),
-          str("xyz"),
-          pattern("[") }) },
-      }, {}, {}};
+        {
+          "rule_A",
+          seq({
+            pattern("("),
+            str("xyz"),
+            pattern("["),
+          }),
+          RuleEntryTypeNamed
+        },
+      }, {}};
 
       auto result = expand_tokens(grammar);
 
diff --git a/spec/compiler/prepare_grammar/extract_tokens_spec.cc b/spec/compiler/prepare_grammar/extract_tokens_spec.cc
index 6f082518..3722dde7 100644
--- a/spec/compiler/prepare_grammar/extract_tokens_spec.cc
+++ b/spec/compiler/prepare_grammar/extract_tokens_spec.cc
@@ -1,6 +1,5 @@
 #include "compiler/compiler_spec_helper.h"
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/prepare_grammar/interned_grammar.h"
 #include "compiler/prepare_grammar/extract_tokens.h"
 #include "compiler/helpers/containers.h"
@@ -12,271 +11,301 @@ using prepare_grammar::extract_tokens;
 using prepare_grammar::InternedGrammar;
 
 describe("extract_tokens", []() {
-  it("moves string rules into the lexical grammar", [&]() {
+  it("moves strings, patterns, and sub-rules marked as tokens into the lexical grammar", [&]() {
     auto result = extract_tokens(InternedGrammar{{
-      { "rule_A", seq({ str("ab"), i_sym(0) }) }
+      {
+        "rule_A",
+        repeat(seq({
+          str("ab"),
+          pattern("cd*"),
+          choice({
+            i_sym(1),
+            i_sym(2),
+            token(repeat(choice({ str("ef"), str("gh") }))),
+          }),
+        })),
+      },
+      {
+        "rule_B",
+        pattern("ij+"),
+      },
+      {
+        "rule_C",
+        choice({ str("kl"), blank() }),
+      },
+      {
+        "rule_D",
+        repeat(i_sym(3))
+      }
     }, {}, {}});
 
-    AssertThat(get<0>(result).rules, Equals(rule_list({
-      { "rule_A", seq({ i_aux_token(0), i_sym(0) }) }
+    SyntaxGrammar &syntax_grammar = get<0>(result);
+    LexicalGrammar &lexical_grammar = get<1>(result);
+    const GrammarError *error = get<2>(result);
+
+    AssertThat(error, Equals<const GrammarError *>(nullptr));
+
+    AssertThat(syntax_grammar.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule_A",
+        repeat(seq({
+
+          // This string is now the first token in the lexical grammar.
+          i_token(0),
+
+          // This pattern is now the second rule in the lexical grammar.
+          i_token(1),
+
+          choice({
+            // Rule 1, which this symbol pointed to, has been moved to the
+            // lexical grammar.
+            i_token(3),
+
+            // This symbol's index has been decremented, because a previous rule
+            // was moved to the lexical grammar.
+            i_sym(1),
+
+            // This token rule is now the third rule in the lexical grammar.
+            i_token(2),
+          }),
+        })),
+        RuleEntryTypeNamed,
+      },
+      {
+        "rule_C",
+        choice({ i_token(4), blank() }),
+        RuleEntryTypeNamed,
+      },
+      {
+        "rule_D",
+        repeat(i_sym(2)),
+        RuleEntryTypeNamed,
+      }
     })));
-    AssertThat(get<0>(result).aux_rules, IsEmpty())
 
-    AssertThat(get<1>(result).rules, IsEmpty())
-    AssertThat(get<1>(result).aux_rules, Equals(rule_list({
-      { "'ab'", str("ab") },
+    AssertThat(lexical_grammar.rules, Equals(eq_vector<RuleEntry>({
+
+      // Strings become anonymous rules.
+      {
+        "ab",
+        str("ab"),
+        RuleEntryTypeAnonymous,
+      },
+
+      // Patterns become hidden rules.
+      {
+        "/cd*/",
+        pattern("cd*"),
+        RuleEntryTypeHidden,
+      },
+
+      // Rules marked as tokens become hidden rules.
+      {
+        "/(ef|gh)*/",
+        repeat(choice({ str("ef"), str("gh") })),
+        RuleEntryTypeHidden,
+      },
+
+      // This named rule was moved wholesale to the lexical grammar.
+      {
+        "rule_B",
+        pattern("ij+"),
+        RuleEntryTypeNamed,
+      },
+
+      // Strings become anonymous rules.
+      {
+        "kl",
+        str("kl"),
+        RuleEntryTypeAnonymous,
+      },
+
     })));
   });
 
-  it("moves pattern rules into the lexical grammar", [&]() {
-    auto result = extract_tokens(InternedGrammar{{
-      { "rule_A", seq({ pattern("a+"), i_sym(0) }) }
-    }, {}, {}});
-
-    AssertThat(get<0>(result).rules, Equals(rule_list({
-      { "rule_A", seq({ i_aux_token(0), i_sym(0) }) }
-    })));
-    AssertThat(get<0>(result).aux_rules, IsEmpty())
-
-    AssertThat(get<1>(result).rules, IsEmpty())
-    AssertThat(get<1>(result).aux_rules, Equals(rule_list({
-      { "/a+/", pattern("a+") },
-    })));
-  });
-
-  it("moves other rules marked as tokens into the lexical grammar", [&]() {
-    auto result = extract_tokens(InternedGrammar{{
-      { "rule_A", seq({
-        token(seq({ pattern("."), choice({ str("a"), str("b") }) })),
-        i_sym(0) }) }
-    }, {}, {}});
-
-    AssertThat(get<0>(result).rules, Equals(rule_list({
-      { "rule_A", seq({ i_aux_token(0), i_sym(0) }) }
-    })));
-    AssertThat(get<0>(result).aux_rules, IsEmpty())
-
-    AssertThat(get<1>(result).rules, IsEmpty())
-    AssertThat(get<1>(result).aux_rules, Equals(rule_list({
-      { "(seq /./ (choice 'a' 'b'))", token(seq({ pattern("."), choice({ str("a"), str("b") }) })) },
-    })));
-  });
-
-  it("does not move blank rules", [&]() {
-    auto result = extract_tokens(InternedGrammar{{
-      { "rule_A", choice({ i_sym(0), blank() }) },
-    }, {}, {}});
-
-    AssertThat(get<0>(result).rules, Equals(rule_list({
-      { "rule_A", choice({ i_sym(0), blank() }) },
-    })));
-    AssertThat(get<0>(result).aux_rules, IsEmpty())
-
-    AssertThat(get<1>(result).rules, IsEmpty())
-    AssertThat(get<1>(result).aux_rules, IsEmpty())
-  });
-
   it("does not create duplicate tokens in the lexical grammar", [&]() {
     auto result = extract_tokens(InternedGrammar{{
-      { "rule_A", seq({ str("ab"), i_sym(0), str("ab") }) },
+      {
+        "rule_A",
+        seq({
+          str("ab"),
+          i_sym(0),
+          str("ab"),
+        })
+      },
     }, {}, {}});
 
-    AssertThat(get<0>(result).rules, Equals(rule_list({
-      { "rule_A", seq({ i_aux_token(0), i_sym(0), i_aux_token(0) }) }
-    })));
-    AssertThat(get<0>(result).aux_rules, IsEmpty())
+    SyntaxGrammar &syntax_grammar = get<0>(result);
+    LexicalGrammar &lexical_grammar = get<1>(result);
 
-    AssertThat(get<1>(result).rules, IsEmpty())
-    AssertThat(get<1>(result).aux_rules, Equals(rule_list({
-      { "'ab'", str("ab") },
+    AssertThat(syntax_grammar.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule_A",
+        seq({ i_token(0), i_sym(0), i_token(0) }),
+        RuleEntryTypeNamed
+      }
+    })));
+
+    AssertThat(lexical_grammar.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "ab",
+        str("ab"),
+        RuleEntryTypeAnonymous
+      },
     })))
   });
 
-  it("updates the grammar's expected conflict symbols", [&]() {
-    auto result = extract_tokens(InternedGrammar{
+  it("does not move entire rules into the lexical grammar if their content is used elsewhere in the grammar", [&]() {
+    auto result = extract_tokens(InternedGrammar{{
       {
-        { "rule_A", str("ok") },
-        { "rule_B", repeat(i_sym(0)) },
-        { "rule_C", repeat(seq({ i_sym(0), i_sym(0) })) },
+        "rule_A",
+        seq({ i_sym(1), str("ab") })
       },
-      { str(" ") },
-      { { Symbol(1), Symbol(2) } }
-    });
+      {
+        "rule_B",
+        str("cd")
+      },
+      {
+        "rule_C",
+        seq({ str("ef"), str("cd") })
+      },
+    }, {}, {}});
 
-    AssertThat(get<0>(result).rules.size(), Equals<size_t>(2));
-    AssertThat(get<1>(result).rules.size(), Equals<size_t>(1));
-    AssertThat(get<0>(result).expected_conflicts, Equals(set<set<Symbol>>({
+    SyntaxGrammar &syntax_grammar = get<0>(result);
+    LexicalGrammar &lexical_grammar = get<1>(result);
+
+    AssertThat(syntax_grammar.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "rule_A",
+        seq({ i_sym(1), i_token(0) }),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule_B",
+        i_token(1),
+        RuleEntryTypeNamed
+      },
+      {
+        "rule_C",
+        seq({ i_token(2), i_token(1) }),
+        RuleEntryTypeNamed
+      },
+    })));
+
+    AssertThat(lexical_grammar.rules, Equals(eq_vector<RuleEntry>({
+      {
+        "ab",
+        str("ab"),
+        RuleEntryTypeAnonymous
+      },
+      {
+        "cd",
+        str("cd"),
+        RuleEntryTypeAnonymous
+      },
+      {
+        "ef",
+        str("ef"),
+        RuleEntryTypeAnonymous
+      },
+    })));
+  });
+
+  it("renumbers the grammar's expected conflict symbols based on any moved rules", [&]() {
+    auto result = extract_tokens(InternedGrammar{{
+      {
+        "rule_A",
+        str("ok")
+      },
+      {
+        "rule_B",
+        repeat(i_sym(0))
+      },
+      {
+        "rule_C",
+        repeat(seq({ i_sym(0), i_sym(0) }))
+      },
+    }, { str(" ") }, { { Symbol(1), Symbol(2) } }});
+
+    SyntaxGrammar &syntax_grammar = get<0>(result);
+
+    AssertThat(syntax_grammar.rules.size(), Equals<size_t>(2));
+    AssertThat(syntax_grammar.expected_conflicts, Equals(set<set<Symbol>>({
       { Symbol(0), Symbol(1) },
     })));
   });
 
-  describe("when an entire grammar rule is a token", [&]() {
-    it("moves the rule the lexical grammar and updates referencing symbols", [&]() {
-      auto result = extract_tokens(InternedGrammar{{
-        { "rule_A", i_sym(1) },
-        { "rule_B", pattern("a|b") },
-        { "rule_C", token(seq({ str("a"), str("b") })) },
-      }, {}, {}});
-
-      AssertThat(get<0>(result).rules, Equals(rule_list({
-        { "rule_A", i_token(0) }
-      })));
-      AssertThat(get<0>(result).aux_rules, IsEmpty());
-
-      AssertThat(get<1>(result).rules, Equals(rule_list({
-        { "rule_B", pattern("a|b") },
-        { "rule_C", token(seq({ str("a"), str("b") })) },
-      })));
-
-      // TODO put back
-      // AssertThat(get<1>(result).aux_rules, IsEmpty());
-    });
-
-    it("updates symbols whose indices need to change due to deleted rules", [&]() {
-      auto result = extract_tokens(InternedGrammar{{
-        { "rule_A", str("ab") },
-        { "rule_B", i_sym(0) },
-        { "rule_C", i_sym(1) },
-      }, {}, {}});
-
-      AssertThat(get<0>(result).rules, Equals(rule_list({
-        { "rule_B", i_token(0) },
-        { "rule_C", i_sym(0) },
-      })));
-      AssertThat(get<0>(result).aux_rules, IsEmpty());
-
-      AssertThat(get<1>(result).rules, Equals(rule_list({
-        { "rule_A", str("ab") },
-      })));
-
-      // TODO put back
-      // AssertThat(get<1>(result).aux_rules, IsEmpty());
-    });
-
-    it("does not move the rule if its content is used elsewhere in the grammar", [&]() {
-      auto result = extract_tokens(InternedGrammar{{
-        { "rule_A", seq({ i_sym(1), str("ab") }) },
-        { "rule_B", str("cd") },
-        { "rule_C", seq({ str("ef"), str("cd") }) },
-      }, {}, {}});
-
-      AssertThat(get<0>(result).rules, Equals(rule_list({
-        { "rule_A", seq({ i_sym(1), i_aux_token(0) }) },
-        { "rule_B", i_aux_token(1) },
-        { "rule_C", seq({ i_aux_token(2), i_aux_token(1) }) },
-      })));
-      AssertThat(get<0>(result).aux_rules, IsEmpty());
-
-      AssertThat(get<1>(result).rules, IsEmpty())
-      AssertThat(get<1>(result).aux_rules, Equals(rule_list({
-        { "'ab'", str("ab") },
-        { "'cd'", str("cd") },
-        { "'ef'", str("ef") },
-      })));
-    });
-  });
-
   describe("handling ubiquitous tokens", [&]() {
-    describe("ubiquitous tokens that are not symbols", [&]() {
-      it("adds them to the lexical grammar's separators", [&]() {
-        auto result = extract_tokens(InternedGrammar{{
-          { "rule_A", str("x") },
-        }, {
-          pattern("\\s+"),
-          str("y"),
-        }, {}});
+    it("adds inline ubiquitous tokens to the lexical grammar's separators", [&]() {
+      auto result = extract_tokens(InternedGrammar{{
+        { "rule_A", str("x") },
+      }, {
+        pattern("\\s+"),
+        str("y"),
+      }, {}});
 
-        AssertThat(get<2>(result), Equals<const GrammarError *>(nullptr));
+      AssertThat(get<2>(result), Equals<const GrammarError *>(nullptr));
 
-        AssertThat(get<1>(result).separators, Equals(rule_vector({
-          pattern("\\s+"),
-          str("y"),
-        })));
+      AssertThat(get<1>(result).separators, Equals(rule_vector({
+        pattern("\\s+"),
+        str("y"),
+      })));
 
-        AssertThat(get<0>(result).ubiquitous_tokens, IsEmpty());
-      });
+      AssertThat(get<0>(result).ubiquitous_tokens, IsEmpty());
     });
 
-    describe("ubiquitous tokens that point to moved rules", [&]() {
-      it("updates them according to the new symbol numbers", [&]() {
-        auto result = extract_tokens(InternedGrammar{ {
-          { "rule_A", seq({ str("w"), i_sym(1) }) },
-          { "rule_B", str("x") },
-          { "rule_C", str("y") },
-        }, {
-          i_sym(2),
-        }, {}});
+    it("updates ubiquitous symbols according to the new symbol numbers", [&]() {
+      auto result = extract_tokens(InternedGrammar{ {
+        { "rule_A", seq({ str("w"), str("x"), i_sym(1) }) },
+        { "rule_B", str("y") },
+        { "rule_C", str("z") },
+      }, {
+        i_sym(2),
+      }, {}});
 
-        AssertThat(get<2>(result), Equals<const GrammarError *>(nullptr));
+      AssertThat(get<2>(result), Equals<const GrammarError *>(nullptr));
 
-        AssertThat(get<0>(result).ubiquitous_tokens, Equals(set<Symbol>({
-          { Symbol(1, SymbolOptionToken) },
-        })));
+      AssertThat(get<0>(result).ubiquitous_tokens, Equals(set<Symbol>({
+        { Symbol(3, true) },
+      })));
 
-        AssertThat(get<1>(result).separators, IsEmpty());
-      });
+      AssertThat(get<1>(result).separators, IsEmpty());
     });
 
-    describe("ubiquitous tokens that are visible", [&]() {
-      it("preserves them in the syntactic grammar", [&]() {
-        auto result = extract_tokens(InternedGrammar{{
-          { "rule_A", str("ab") },
-          { "rule_B", str("bc") },
-        }, { i_sym(1) }, {}});
+    it("returns an error if any ubiquitous tokens are non-token symbols", [&]() {
+      auto result = extract_tokens(InternedGrammar{{
+        {
+          "rule_A",
+          seq({ str("x"), i_sym(1) }),
+        },
+        {
+          "rule_B",
+          seq({ str("y"), str("z") })
+        },
+      }, { i_sym(1) }, {}});
 
-        AssertThat(get<2>(result), Equals<const GrammarError *>(nullptr));
-
-        AssertThat(get<0>(result).ubiquitous_tokens, Equals(set<Symbol>({
-          Symbol(1, SymbolOptionToken)
-        })));
-
-        AssertThat(get<1>(result).separators, IsEmpty());
-      });
+      AssertThat(get<2>(result), !Equals<const GrammarError *>(nullptr));
+      AssertThat(get<2>(result), EqualsPointer(
+        new GrammarError(GrammarErrorTypeInvalidUbiquitousToken,
+                         "Not a token: rule_B")));
     });
 
-    describe("ubiquitous tokens that are used in other grammar rules", [&]() {
-      it("preserves them in the syntactic grammar", [&]() {
-        auto result = extract_tokens(InternedGrammar{{
-          { "rule_A", seq({ i_sym(1), str("ab") }) },
-          { "_rule_B", str("bc") },
-        }, { i_sym(1) }, {}});
+    it("returns an error if any ubiquitous tokens are non-token rules", [&]() {
+      auto result = extract_tokens(InternedGrammar{{
+        {
+          "rule_A",
+          str("x")
+        },
+        {
+          "rule_B",
+          str("y")
+        },
+      }, { choice({ i_sym(1), blank() }) }, {}});
 
-        AssertThat(get<2>(result), Equals<const GrammarError *>(nullptr));
-
-        AssertThat(get<0>(result).ubiquitous_tokens, Equals(set<Symbol>({
-          Symbol(0, SymbolOptionToken),
-        })));
-
-        AssertThat(get<1>(result).separators, IsEmpty());
-      });
-    });
-
-    describe("ubiquitous tokens that are non-token symbols", [&]() {
-      it("returns an error", [&]() {
-        auto result = extract_tokens(InternedGrammar{{
-          { "rule_A", seq({ str("x"), i_sym(1) }), },
-          { "rule_B", seq({ str("y"), str("z") }) },
-        }, { i_sym(1) }, {}});
-
-        AssertThat(get<2>(result), !Equals<const GrammarError *>(nullptr));
-        AssertThat(get<2>(result), EqualsPointer(
-          new GrammarError(GrammarErrorTypeInvalidUbiquitousToken,
-                           "Not a token: rule_B")));
-      });
-    });
-
-    describe("ubiquitous tokens that are not symbols", [&]() {
-      it("returns an error", [&]() {
-        auto result = extract_tokens(InternedGrammar{{
-          { "rule_A", str("x") },
-          { "rule_B", str("y") },
-        }, { choice({ i_sym(1), blank() }) }, {}});
-
-        AssertThat(get<2>(result), !Equals<const GrammarError *>(nullptr));
-        AssertThat(get<2>(result), EqualsPointer(
-          new GrammarError(GrammarErrorTypeInvalidUbiquitousToken,
-                           "Not a token: (choice (sym 1) (blank))")));
-      });
+      AssertThat(get<2>(result), !Equals<const GrammarError *>(nullptr));
+      AssertThat(get<2>(result), EqualsPointer(
+        new GrammarError(GrammarErrorTypeInvalidUbiquitousToken,
+                         "Not a token: (choice (sym 1) (blank))")));
     });
   });
 });
diff --git a/spec/fixtures/parsers/arithmetic.c b/spec/fixtures/parsers/arithmetic.c
index 148e6ef0..76dbe16f 100644
--- a/spec/fixtures/parsers/arithmetic.c
+++ b/spec/fixtures/parsers/arithmetic.c
@@ -12,16 +12,16 @@ enum {
     sym_quotient,
     sym_exponent,
     sym_group,
+    aux_sym_PLUS,
+    aux_sym_DASH,
+    aux_sym_STAR,
+    aux_sym_SLASH,
+    aux_sym_CARET,
+    aux_sym_LPAREN,
+    aux_sym_RPAREN,
     sym_number,
     sym_variable,
     sym_comment,
-    aux_sym_STR_PLUS,
-    aux_sym_STR_DASH,
-    aux_sym_STR_STAR,
-    aux_sym_STR_SLASH,
-    aux_sym_STR_CARET,
-    aux_sym_STR_LPAREN,
-    aux_sym_STR_RPAREN,
 };
 
 static const char *ts_symbol_names[] = {
@@ -35,27 +35,27 @@ static const char *ts_symbol_names[] = {
     [sym_group] = "group",
     [ts_builtin_sym_error] = "ERROR",
     [ts_builtin_sym_end] = "END",
+    [aux_sym_PLUS] = "+",
+    [aux_sym_DASH] = "-",
+    [aux_sym_STAR] = "*",
+    [aux_sym_SLASH] = "/",
+    [aux_sym_CARET] = "^",
+    [aux_sym_LPAREN] = "(",
+    [aux_sym_RPAREN] = ")",
     [sym_number] = "number",
     [sym_variable] = "variable",
     [sym_comment] = "comment",
-    [aux_sym_STR_PLUS] = "STR_+",
-    [aux_sym_STR_DASH] = "STR_-",
-    [aux_sym_STR_STAR] = "STR_*",
-    [aux_sym_STR_SLASH] = "STR_/",
-    [aux_sym_STR_CARET] = "STR_^",
-    [aux_sym_STR_LPAREN] = "STR_(",
-    [aux_sym_STR_RPAREN] = "STR_)",
 };
 
 static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
     [sym__expression] = 1,
-    [aux_sym_STR_PLUS] = 1,
-    [aux_sym_STR_DASH] = 1,
-    [aux_sym_STR_STAR] = 1,
-    [aux_sym_STR_SLASH] = 1,
-    [aux_sym_STR_CARET] = 1,
-    [aux_sym_STR_LPAREN] = 1,
-    [aux_sym_STR_RPAREN] = 1,
+    [aux_sym_PLUS] = 1,
+    [aux_sym_DASH] = 1,
+    [aux_sym_STAR] = 1,
+    [aux_sym_SLASH] = 1,
+    [aux_sym_CARET] = 1,
+    [aux_sym_LPAREN] = 1,
+    [aux_sym_RPAREN] = 1,
 };
 
 static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@@ -85,7 +85,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(2);
             ACCEPT_TOKEN(sym_comment);
         case 3:
-            ACCEPT_TOKEN(aux_sym_STR_LPAREN);
+            ACCEPT_TOKEN(aux_sym_LPAREN);
         case 4:
             if ('0' <= lookahead && lookahead <= '9')
                 ADVANCE(4);
@@ -139,15 +139,15 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(14);
             LEX_ERROR();
         case 10:
-            ACCEPT_TOKEN(aux_sym_STR_STAR);
+            ACCEPT_TOKEN(aux_sym_STAR);
         case 11:
-            ACCEPT_TOKEN(aux_sym_STR_PLUS);
+            ACCEPT_TOKEN(aux_sym_PLUS);
         case 12:
-            ACCEPT_TOKEN(aux_sym_STR_DASH);
+            ACCEPT_TOKEN(aux_sym_DASH);
         case 13:
-            ACCEPT_TOKEN(aux_sym_STR_SLASH);
+            ACCEPT_TOKEN(aux_sym_SLASH);
         case 14:
-            ACCEPT_TOKEN(aux_sym_STR_CARET);
+            ACCEPT_TOKEN(aux_sym_CARET);
         case 15:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -171,7 +171,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(14);
             LEX_ERROR();
         case 16:
-            ACCEPT_TOKEN(aux_sym_STR_RPAREN);
+            ACCEPT_TOKEN(aux_sym_RPAREN);
         case 17:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -302,10 +302,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(3)),
         [sym_exponent] = ACTIONS(SHIFT(3)),
         [sym_group] = ACTIONS(SHIFT(3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(3)),
         [sym_variable] = ACTIONS(SHIFT(3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
     },
     [1] = {
         [ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
@@ -313,21 +313,21 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [2] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(23)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(24)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(25)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(26)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(26)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
     },
     [3] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [4] = {
         [sym__expression] = ACTIONS(SHIFT(5)),
@@ -338,32 +338,32 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_exponent] = ACTIONS(SHIFT(6)),
         [sym_group] = ACTIONS(SHIFT(6)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(8)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_variable] = ACTIONS(SHIFT(6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
     },
     [5] = {
+        [aux_sym_PLUS] = ACTIONS(SHIFT(12)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(13)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(14)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(15)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(16)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(22)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(22)),
     },
     [6] = {
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [7] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(22)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(22)),
     },
     [8] = {
         [sym__expression] = ACTIONS(SHIFT(9)),
@@ -374,32 +374,32 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_exponent] = ACTIONS(SHIFT(6)),
         [sym_group] = ACTIONS(SHIFT(6)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(10)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(8)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_variable] = ACTIONS(SHIFT(6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
     },
     [9] = {
+        [aux_sym_PLUS] = ACTIONS(SHIFT(12)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(13)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(14)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(15)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(16)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(11)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(11)),
     },
     [10] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(11)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(11)),
     },
     [11] = {
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_CARET] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_group, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_group, 3)),
     },
     [12] = {
         [sym__expression] = ACTIONS(SHIFT(21)),
@@ -409,10 +409,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(6)),
         [sym_exponent] = ACTIONS(SHIFT(6)),
         [sym_group] = ACTIONS(SHIFT(6)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(8)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_variable] = ACTIONS(SHIFT(6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
     },
     [13] = {
         [sym__expression] = ACTIONS(SHIFT(20)),
@@ -422,10 +422,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(6)),
         [sym_exponent] = ACTIONS(SHIFT(6)),
         [sym_group] = ACTIONS(SHIFT(6)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(8)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_variable] = ACTIONS(SHIFT(6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
     },
     [14] = {
         [sym__expression] = ACTIONS(SHIFT(19)),
@@ -435,10 +435,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(6)),
         [sym_exponent] = ACTIONS(SHIFT(6)),
         [sym_group] = ACTIONS(SHIFT(6)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(8)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_variable] = ACTIONS(SHIFT(6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
     },
     [15] = {
         [sym__expression] = ACTIONS(SHIFT(18)),
@@ -448,10 +448,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(6)),
         [sym_exponent] = ACTIONS(SHIFT(6)),
         [sym_group] = ACTIONS(SHIFT(6)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(8)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_variable] = ACTIONS(SHIFT(6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
     },
     [16] = {
         [sym__expression] = ACTIONS(SHIFT(17)),
@@ -461,64 +461,64 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(6)),
         [sym_exponent] = ACTIONS(SHIFT(6)),
         [sym_group] = ACTIONS(SHIFT(6)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(8)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_variable] = ACTIONS(SHIFT(6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(8)),
     },
     [17] = {
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_CARET] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
     },
     [18] = {
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(16)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
     },
     [19] = {
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(16)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
     },
     [20] = {
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(14)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(15)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(16)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
     },
     [21] = {
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(14)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(15)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(16)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
     },
     [22] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_group, 3)),
+        [aux_sym_CARET] = ACTIONS(REDUCE(sym_group, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_group, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(REDUCE(sym_group, 3)),
     },
     [23] = {
         [sym__expression] = ACTIONS(SHIFT(32)),
@@ -528,10 +528,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(3)),
         [sym_exponent] = ACTIONS(SHIFT(3)),
         [sym_group] = ACTIONS(SHIFT(3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(3)),
         [sym_variable] = ACTIONS(SHIFT(3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
     },
     [24] = {
         [sym__expression] = ACTIONS(SHIFT(31)),
@@ -541,10 +541,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(3)),
         [sym_exponent] = ACTIONS(SHIFT(3)),
         [sym_group] = ACTIONS(SHIFT(3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(3)),
         [sym_variable] = ACTIONS(SHIFT(3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
     },
     [25] = {
         [sym__expression] = ACTIONS(SHIFT(30)),
@@ -554,10 +554,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(3)),
         [sym_exponent] = ACTIONS(SHIFT(3)),
         [sym_group] = ACTIONS(SHIFT(3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(3)),
         [sym_variable] = ACTIONS(SHIFT(3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
     },
     [26] = {
         [sym__expression] = ACTIONS(SHIFT(29)),
@@ -567,10 +567,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(3)),
         [sym_exponent] = ACTIONS(SHIFT(3)),
         [sym_group] = ACTIONS(SHIFT(3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(3)),
         [sym_variable] = ACTIONS(SHIFT(3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
     },
     [27] = {
         [sym__expression] = ACTIONS(SHIFT(28)),
@@ -580,55 +580,55 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_quotient] = ACTIONS(SHIFT(3)),
         [sym_exponent] = ACTIONS(SHIFT(3)),
         [sym_group] = ACTIONS(SHIFT(3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(3)),
         [sym_variable] = ACTIONS(SHIFT(3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(4)),
     },
     [28] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
+        [aux_sym_CARET] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(REDUCE_FRAGILE(sym_exponent, 3)),
     },
     [29] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
     },
     [30] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
     },
     [31] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(25)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(26)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(26)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
     },
     [32] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(25)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(26)),
+        [aux_sym_CARET] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(26)),
-        [aux_sym_STR_CARET] = ACTIONS(SHIFT(27)),
     },
 };
 
diff --git a/spec/fixtures/parsers/c.c b/spec/fixtures/parsers/c.c
index 9614c8d6..aa2f2ffa 100644
--- a/spec/fixtures/parsers/c.c
+++ b/spec/fixtures/parsers/c.c
@@ -28,10 +28,6 @@ enum {
     sym_call_expression,
     sym_statement,
     sym_expression_statement,
-    sym_string,
-    sym_identifier,
-    sym_number,
-    sym_comment,
     aux_sym_function_definition_repeat1,
     aux_sym_declaration_specifiers_repeat1,
     aux_sym_type_name_repeat1,
@@ -42,31 +38,35 @@ enum {
     aux_sym__direct_declarator_repeat1,
     aux_sym_compound_statement_repeat1,
     aux_sym_call_expression_repeat1,
-    aux_sym_STR_typedef,
-    aux_sym_STR_extern,
-    aux_sym_STR_static,
-    aux_sym_STR_auto,
-    aux_sym_STR_register,
-    aux_sym_STR_signed,
-    aux_sym_STR_unsigned,
-    aux_sym_STR_long,
-    aux_sym_STR_short,
-    aux_sym_STR_struct,
-    aux_sym_STR_LBRACE,
-    aux_sym_STR_RBRACE,
-    aux_sym_STR_COMMA,
-    aux_sym_STR_SEMI,
-    aux_sym_STR_EQ,
-    aux_sym_STR_LBRACK,
-    aux_sym_STR_RBRACK,
-    aux_sym_STR_DOT,
-    aux_sym_STR_LPAREN,
-    aux_sym_STR_RPAREN,
-    aux_sym_STR_const,
-    aux_sym_STR_restrict,
-    aux_sym_STR_volatile,
-    aux_sym_STR_STAR,
-    aux_sym_STR_PLUS,
+    aux_sym_typedef,
+    aux_sym_extern,
+    aux_sym_static,
+    aux_sym_auto,
+    aux_sym_register,
+    aux_sym_signed,
+    aux_sym_unsigned,
+    aux_sym_long,
+    aux_sym_short,
+    aux_sym_struct,
+    aux_sym_LBRACE,
+    aux_sym_RBRACE,
+    aux_sym_COMMA,
+    aux_sym_SEMI,
+    aux_sym_EQ,
+    aux_sym_LBRACK,
+    aux_sym_RBRACK,
+    aux_sym_DOT,
+    aux_sym_LPAREN,
+    aux_sym_RPAREN,
+    aux_sym_const,
+    aux_sym_restrict,
+    aux_sym_volatile,
+    aux_sym_STAR,
+    aux_sym_PLUS,
+    sym_string,
+    sym_identifier,
+    sym_number,
+    sym_comment,
 };
 
 static const char *ts_symbol_names[] = {
@@ -94,12 +94,6 @@ static const char *ts_symbol_names[] = {
     [sym_call_expression] = "call_expression",
     [sym_statement] = "statement",
     [sym_expression_statement] = "expression_statement",
-    [ts_builtin_sym_error] = "ERROR",
-    [ts_builtin_sym_end] = "END",
-    [sym_string] = "string",
-    [sym_identifier] = "identifier",
-    [sym_number] = "number",
-    [sym_comment] = "comment",
     [aux_sym_function_definition_repeat1] = "function_definition_repeat1",
     [aux_sym_declaration_specifiers_repeat1] = "declaration_specifiers_repeat1",
     [aux_sym_type_name_repeat1] = "type_name_repeat1",
@@ -110,31 +104,37 @@ static const char *ts_symbol_names[] = {
     [aux_sym__direct_declarator_repeat1] = "_direct_declarator_repeat1",
     [aux_sym_compound_statement_repeat1] = "compound_statement_repeat1",
     [aux_sym_call_expression_repeat1] = "call_expression_repeat1",
-    [aux_sym_STR_typedef] = "STR_typedef",
-    [aux_sym_STR_extern] = "STR_extern",
-    [aux_sym_STR_static] = "STR_static",
-    [aux_sym_STR_auto] = "STR_auto",
-    [aux_sym_STR_register] = "STR_register",
-    [aux_sym_STR_signed] = "STR_signed",
-    [aux_sym_STR_unsigned] = "STR_unsigned",
-    [aux_sym_STR_long] = "STR_long",
-    [aux_sym_STR_short] = "STR_short",
-    [aux_sym_STR_struct] = "STR_struct",
-    [aux_sym_STR_LBRACE] = "STR_{",
-    [aux_sym_STR_RBRACE] = "STR_}",
-    [aux_sym_STR_COMMA] = "STR_,",
-    [aux_sym_STR_SEMI] = "STR_;",
-    [aux_sym_STR_EQ] = "STR_=",
-    [aux_sym_STR_LBRACK] = "STR_[",
-    [aux_sym_STR_RBRACK] = "STR_]",
-    [aux_sym_STR_DOT] = "STR_.",
-    [aux_sym_STR_LPAREN] = "STR_(",
-    [aux_sym_STR_RPAREN] = "STR_)",
-    [aux_sym_STR_const] = "STR_const",
-    [aux_sym_STR_restrict] = "STR_restrict",
-    [aux_sym_STR_volatile] = "STR_volatile",
-    [aux_sym_STR_STAR] = "STR_*",
-    [aux_sym_STR_PLUS] = "STR_+",
+    [ts_builtin_sym_error] = "ERROR",
+    [ts_builtin_sym_end] = "END",
+    [aux_sym_typedef] = "typedef",
+    [aux_sym_extern] = "extern",
+    [aux_sym_static] = "static",
+    [aux_sym_auto] = "auto",
+    [aux_sym_register] = "register",
+    [aux_sym_signed] = "signed",
+    [aux_sym_unsigned] = "unsigned",
+    [aux_sym_long] = "long",
+    [aux_sym_short] = "short",
+    [aux_sym_struct] = "struct",
+    [aux_sym_LBRACE] = "{",
+    [aux_sym_RBRACE] = "}",
+    [aux_sym_COMMA] = ",",
+    [aux_sym_SEMI] = ";",
+    [aux_sym_EQ] = "=",
+    [aux_sym_LBRACK] = "[",
+    [aux_sym_RBRACK] = "]",
+    [aux_sym_DOT] = ".",
+    [aux_sym_LPAREN] = "(",
+    [aux_sym_RPAREN] = ")",
+    [aux_sym_const] = "const",
+    [aux_sym_restrict] = "restrict",
+    [aux_sym_volatile] = "volatile",
+    [aux_sym_STAR] = "*",
+    [aux_sym_PLUS] = "+",
+    [sym_string] = "string",
+    [sym_identifier] = "identifier",
+    [sym_number] = "number",
+    [sym_comment] = "comment",
 };
 
 static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
@@ -151,31 +151,31 @@ static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
     [aux_sym__direct_declarator_repeat1] = 1,
     [aux_sym_compound_statement_repeat1] = 1,
     [aux_sym_call_expression_repeat1] = 1,
-    [aux_sym_STR_typedef] = 1,
-    [aux_sym_STR_extern] = 1,
-    [aux_sym_STR_static] = 1,
-    [aux_sym_STR_auto] = 1,
-    [aux_sym_STR_register] = 1,
-    [aux_sym_STR_signed] = 1,
-    [aux_sym_STR_unsigned] = 1,
-    [aux_sym_STR_long] = 1,
-    [aux_sym_STR_short] = 1,
-    [aux_sym_STR_struct] = 1,
-    [aux_sym_STR_LBRACE] = 1,
-    [aux_sym_STR_RBRACE] = 1,
-    [aux_sym_STR_COMMA] = 1,
-    [aux_sym_STR_SEMI] = 1,
-    [aux_sym_STR_EQ] = 1,
-    [aux_sym_STR_LBRACK] = 1,
-    [aux_sym_STR_RBRACK] = 1,
-    [aux_sym_STR_DOT] = 1,
-    [aux_sym_STR_LPAREN] = 1,
-    [aux_sym_STR_RPAREN] = 1,
-    [aux_sym_STR_const] = 1,
-    [aux_sym_STR_restrict] = 1,
-    [aux_sym_STR_volatile] = 1,
-    [aux_sym_STR_STAR] = 1,
-    [aux_sym_STR_PLUS] = 1,
+    [aux_sym_typedef] = 1,
+    [aux_sym_extern] = 1,
+    [aux_sym_static] = 1,
+    [aux_sym_auto] = 1,
+    [aux_sym_register] = 1,
+    [aux_sym_signed] = 1,
+    [aux_sym_unsigned] = 1,
+    [aux_sym_long] = 1,
+    [aux_sym_short] = 1,
+    [aux_sym_struct] = 1,
+    [aux_sym_LBRACE] = 1,
+    [aux_sym_RBRACE] = 1,
+    [aux_sym_COMMA] = 1,
+    [aux_sym_SEMI] = 1,
+    [aux_sym_EQ] = 1,
+    [aux_sym_LBRACK] = 1,
+    [aux_sym_RBRACK] = 1,
+    [aux_sym_DOT] = 1,
+    [aux_sym_LPAREN] = 1,
+    [aux_sym_RPAREN] = 1,
+    [aux_sym_const] = 1,
+    [aux_sym_restrict] = 1,
+    [aux_sym_volatile] = 1,
+    [aux_sym_STAR] = 1,
+    [aux_sym_PLUS] = 1,
 };
 
 static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@@ -268,7 +268,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_auto);
+            ACCEPT_TOKEN(aux_sym_auto);
         case 9:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -315,7 +315,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_const);
+            ACCEPT_TOKEN(aux_sym_const);
         case 14:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -373,7 +373,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_extern);
+            ACCEPT_TOKEN(aux_sym_extern);
         case 20:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -410,7 +410,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_long);
+            ACCEPT_TOKEN(aux_sym_long);
         case 24:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -490,7 +490,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_register);
+            ACCEPT_TOKEN(aux_sym_register);
         case 32:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -548,7 +548,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_restrict);
+            ACCEPT_TOKEN(aux_sym_restrict);
         case 38:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -600,7 +600,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_short);
+            ACCEPT_TOKEN(aux_sym_short);
         case 43:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -647,7 +647,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_signed);
+            ACCEPT_TOKEN(aux_sym_signed);
         case 48:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -697,7 +697,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_static);
+            ACCEPT_TOKEN(aux_sym_static);
         case 53:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -735,7 +735,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_struct);
+            ACCEPT_TOKEN(aux_sym_struct);
         case 57:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -802,7 +802,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_typedef);
+            ACCEPT_TOKEN(aux_sym_typedef);
         case 64:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -879,7 +879,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_unsigned);
+            ACCEPT_TOKEN(aux_sym_unsigned);
         case 72:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -955,7 +955,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_volatile);
+            ACCEPT_TOKEN(aux_sym_volatile);
         case 80:
             START_TOKEN();
             if (lookahead == 0)
@@ -1035,9 +1035,9 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(4);
             LEX_ERROR();
         case 86:
-            ACCEPT_TOKEN(aux_sym_STR_LPAREN);
+            ACCEPT_TOKEN(aux_sym_LPAREN);
         case 87:
-            ACCEPT_TOKEN(aux_sym_STR_STAR);
+            ACCEPT_TOKEN(aux_sym_STAR);
         case 88:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1101,7 +1101,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(92);
             LEX_ERROR();
         case 92:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACE);
+            ACCEPT_TOKEN(aux_sym_LBRACE);
         case 93:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1111,18 +1111,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(93);
             if (lookahead == '/')
                 ADVANCE(2);
-            if (lookahead == '{')
-                ADVANCE(92);
-            LEX_ERROR();
-        case 94:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\n') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(94);
-            if (lookahead == '/')
-                ADVANCE(2);
             if (('A' <= lookahead && lookahead <= 'Z') ||
                 ('a' <= lookahead && lookahead <= 'k') ||
                 ('m' <= lookahead && lookahead <= 'r') ||
@@ -1136,10 +1124,22 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == 'u')
                 ADVANCE(64);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
+        case 94:
+            ACCEPT_TOKEN(aux_sym_RBRACE);
         case 95:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACE);
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\n') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(95);
+            if (lookahead == '/')
+                ADVANCE(2);
+            if (lookahead == '{')
+                ADVANCE(92);
+            LEX_ERROR();
         case 96:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1150,7 +1150,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '/')
                 ADVANCE(2);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         case 97:
             START_TOKEN();
@@ -1178,10 +1178,10 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == 'u')
                 ADVANCE(64);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         case 98:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACK);
+            ACCEPT_TOKEN(aux_sym_LBRACK);
         case 99:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1210,7 +1210,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(2);
             LEX_ERROR();
         case 101:
-            ACCEPT_TOKEN(aux_sym_STR_RPAREN);
+            ACCEPT_TOKEN(aux_sym_RPAREN);
         case 102:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1303,7 +1303,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(111);
             ACCEPT_TOKEN(sym_number);
         case 112:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACK);
+            ACCEPT_TOKEN(aux_sym_RBRACK);
         case 113:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1356,7 +1356,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(2);
             LEX_ERROR();
         case 115:
-            ACCEPT_TOKEN(aux_sym_STR_COMMA);
+            ACCEPT_TOKEN(aux_sym_COMMA);
         case 116:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1394,7 +1394,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(112);
             LEX_ERROR();
         case 118:
-            ACCEPT_TOKEN(aux_sym_STR_PLUS);
+            ACCEPT_TOKEN(aux_sym_PLUS);
         case 119:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1466,7 +1466,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(123);
             LEX_ERROR();
         case 123:
-            ACCEPT_TOKEN(aux_sym_STR_SEMI);
+            ACCEPT_TOKEN(aux_sym_SEMI);
         case 124:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1511,7 +1511,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(92);
             LEX_ERROR();
         case 125:
-            ACCEPT_TOKEN(aux_sym_STR_EQ);
+            ACCEPT_TOKEN(aux_sym_EQ);
         case 126:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1635,7 +1635,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == 'v')
                 ADVANCE(72);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         case 129:
             START_TOKEN();
@@ -1700,7 +1700,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(92);
             LEX_ERROR();
         case 132:
-            ACCEPT_TOKEN(aux_sym_STR_DOT);
+            ACCEPT_TOKEN(aux_sym_DOT);
         case 133:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1713,7 +1713,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '/')
                 ADVANCE(2);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         case 134:
             START_TOKEN();
@@ -1733,7 +1733,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '/')
                 ADVANCE(2);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         case 135:
             START_TOKEN();
@@ -1786,7 +1786,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '{')
                 ADVANCE(92);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         case 138:
             START_TOKEN();
@@ -1938,7 +1938,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '{')
                 ADVANCE(92);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         case ts_lex_state_error:
             START_TOKEN();
@@ -2003,7 +2003,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '{')
                 ADVANCE(92);
             if (lookahead == '}')
-                ADVANCE(95);
+                ADVANCE(94);
             LEX_ERROR();
         default:
             LEX_ERROR();
@@ -2018,113 +2018,113 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [4] = 1,
     [5] = 85,
     [6] = 85,
-    [7] = 85,
-    [8] = 88,
-    [9] = 1,
-    [10] = 89,
-    [11] = 91,
-    [12] = 1,
+    [7] = 88,
+    [8] = 1,
+    [9] = 89,
+    [10] = 91,
+    [11] = 1,
+    [12] = 85,
     [13] = 93,
-    [14] = 94,
-    [15] = 85,
+    [14] = 95,
+    [15] = 93,
     [16] = 85,
-    [17] = 94,
-    [18] = 85,
+    [17] = 85,
+    [18] = 93,
     [19] = 88,
     [20] = 96,
     [21] = 91,
     [22] = 85,
-    [23] = 93,
-    [24] = 94,
-    [25] = 96,
-    [26] = 85,
-    [27] = 85,
-    [28] = 94,
-    [29] = 96,
-    [30] = 85,
+    [23] = 85,
+    [24] = 93,
+    [25] = 95,
+    [26] = 93,
+    [27] = 96,
+    [28] = 85,
+    [29] = 85,
+    [30] = 96,
     [31] = 85,
     [32] = 85,
-    [33] = 96,
-    [34] = 94,
-    [35] = 97,
-    [36] = 85,
-    [37] = 97,
+    [33] = 85,
+    [34] = 96,
+    [35] = 93,
+    [36] = 97,
+    [37] = 85,
     [38] = 99,
     [39] = 85,
     [40] = 85,
-    [41] = 100,
-    [42] = 102,
+    [41] = 97,
+    [42] = 100,
     [43] = 102,
     [44] = 99,
     [45] = 85,
-    [46] = 100,
-    [47] = 102,
+    [46] = 102,
+    [47] = 100,
     [48] = 102,
-    [49] = 103,
-    [50] = 113,
-    [51] = 82,
-    [52] = 85,
-    [53] = 114,
-    [54] = 100,
-    [55] = 1,
-    [56] = 102,
-    [57] = 114,
-    [58] = 100,
-    [59] = 102,
-    [60] = 114,
-    [61] = 116,
+    [49] = 102,
+    [50] = 103,
+    [51] = 113,
+    [52] = 82,
+    [53] = 85,
+    [54] = 114,
+    [55] = 100,
+    [56] = 1,
+    [57] = 102,
+    [58] = 114,
+    [59] = 100,
+    [60] = 102,
+    [61] = 114,
     [62] = 116,
     [63] = 99,
     [64] = 85,
-    [65] = 100,
-    [66] = 116,
+    [65] = 116,
+    [66] = 100,
     [67] = 116,
-    [68] = 103,
-    [69] = 113,
-    [70] = 114,
-    [71] = 100,
-    [72] = 116,
+    [68] = 116,
+    [69] = 103,
+    [70] = 113,
+    [71] = 114,
+    [72] = 100,
     [73] = 116,
-    [74] = 117,
+    [74] = 116,
     [75] = 117,
-    [76] = 119,
-    [77] = 120,
+    [76] = 117,
+    [77] = 119,
     [78] = 120,
-    [79] = 117,
+    [79] = 120,
     [80] = 117,
-    [81] = 121,
+    [81] = 117,
     [82] = 121,
-    [83] = 117,
-    [84] = 100,
-    [85] = 120,
-    [86] = 119,
-    [87] = 117,
-    [88] = 120,
+    [83] = 121,
+    [84] = 117,
+    [85] = 100,
+    [86] = 120,
+    [87] = 119,
+    [88] = 117,
     [89] = 120,
-    [90] = 121,
+    [90] = 120,
     [91] = 121,
     [92] = 121,
     [93] = 121,
-    [94] = 100,
-    [95] = 121,
+    [94] = 121,
+    [95] = 100,
     [96] = 121,
     [97] = 121,
-    [98] = 100,
-    [99] = 117,
-    [100] = 85,
-    [101] = 114,
-    [102] = 117,
-    [103] = 97,
+    [98] = 121,
+    [99] = 100,
+    [100] = 117,
+    [101] = 85,
+    [102] = 114,
+    [103] = 117,
     [104] = 97,
-    [105] = 103,
-    [106] = 113,
-    [107] = 114,
-    [108] = 100,
-    [109] = 97,
+    [105] = 97,
+    [106] = 103,
+    [107] = 113,
+    [108] = 114,
+    [109] = 100,
     [110] = 97,
-    [111] = 117,
-    [112] = 99,
-    [113] = 94,
+    [111] = 97,
+    [112] = 117,
+    [113] = 99,
     [114] = 96,
     [115] = 85,
     [116] = 88,
@@ -2132,9 +2132,9 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [118] = 122,
     [119] = 124,
     [120] = 126,
-    [121] = 126,
-    [122] = 99,
-    [123] = 85,
+    [121] = 99,
+    [122] = 85,
+    [123] = 126,
     [124] = 100,
     [125] = 126,
     [126] = 126,
@@ -2149,7 +2149,7 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [135] = 85,
     [136] = 127,
     [137] = 80,
-    [138] = 93,
+    [138] = 95,
     [139] = 128,
     [140] = 129,
     [141] = 122,
@@ -2216,9 +2216,9 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [202] = 138,
     [203] = 138,
     [204] = 128,
-    [205] = 139,
-    [206] = 96,
-    [207] = 80,
+    [205] = 96,
+    [206] = 80,
+    [207] = 139,
     [208] = 80,
     [209] = 128,
     [210] = 119,
@@ -2235,9 +2235,9 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [221] = 122,
     [222] = 140,
     [223] = 141,
-    [224] = 141,
-    [225] = 99,
-    [226] = 85,
+    [224] = 99,
+    [225] = 85,
+    [226] = 141,
     [227] = 100,
     [228] = 141,
     [229] = 141,
@@ -2259,7 +2259,7 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [245] = 142,
     [246] = 128,
     [247] = 80,
-    [248] = 93,
+    [248] = 95,
     [249] = 122,
     [250] = 142,
     [251] = 127,
@@ -2277,7 +2277,7 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [263] = 85,
     [264] = 122,
     [265] = 124,
-    [266] = 93,
+    [266] = 95,
     [267] = 80,
     [268] = 142,
     [269] = 80,
@@ -2297,22 +2297,22 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
         [sym_declaration] = ACTIONS(SHIFT(2)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(7)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(12)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
     },
     [1] = {
         [ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
@@ -2326,14 +2326,14 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym__type_specifier] = ACTIONS(SHIFT(263)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_identifier] = ACTIONS(SHIFT(7)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [sym_identifier] = ACTIONS(SHIFT(12)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
     },
     [4] = {
         [sym_storage_class_specifier] = ACTIONS(SHIFT(260)),
@@ -2341,1073 +2341,1073 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_name] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
         [sym_struct_specifier] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
         [sym_type_qualifier] = ACTIONS(SHIFT(260)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(261)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declaration_specifiers, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [5] = {
         [sym__init_declarator] = ACTIONS(SHIFT(118)),
         [sym_declarator] = ACTIONS(SHIFT(119)),
         [sym__direct_declarator] = ACTIONS(SHIFT(120)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(121)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(121)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(122)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(123)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [6] = {
         [sym__init_declarator] = ACTIONS(REDUCE(sym__type_specifier, 1)),
         [sym_declarator] = ACTIONS(REDUCE(sym__type_specifier, 1)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym__type_specifier, 1)),
         [sym_pointer] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__type_specifier, 1)),
         [sym_identifier] = ACTIONS(REDUCE(sym__type_specifier, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__type_specifier, 1)),
     },
     [7] = {
-        [sym__init_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_pointer] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_type_name, 1)),
-    },
-    [8] = {
         [sym_identifier] = ACTIONS(SHIFT(117)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [9] = {
+    [8] = {
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
         [sym_type_name] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
         [sym_struct_specifier] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_storage_class_specifier, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [10] = {
+    [9] = {
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(116)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
         [sym_identifier] = ACTIONS(REDUCE(aux_sym_type_name_repeat1, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
+    },
+    [10] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(13)),
+        [sym_identifier] = ACTIONS(SHIFT(14)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [11] = {
-        [sym_identifier] = ACTIONS(SHIFT(13)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(14)),
-    },
-    [12] = {
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
         [sym_type_name] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
         [sym_struct_specifier] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
-    },
-    [13] = {
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_type_qualifier, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(113)),
     },
-    [14] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(15)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_struct_declaration] = ACTIONS(SHIFT(17)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(22)),
-    },
-    [15] = {
-        [sym_declarator] = ACTIONS(SHIFT(34)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(35)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(37)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
-    },
-    [16] = {
-        [sym_declarator] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [sym_pointer] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__type_specifier, 1)),
-    },
-    [17] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(15)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_struct_declaration] = ACTIONS(SHIFT(17)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(33)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_specifier_repeat1, 1)),
-    },
-    [18] = {
+    [12] = {
+        [sym__init_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_pointer] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_type_name, 1)),
+    },
+    [13] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(16)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_struct_declaration] = ACTIONS(SHIFT(18)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(114)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(115)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [14] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(15)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [15] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(16)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_struct_declaration] = ACTIONS(SHIFT(18)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(20)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(22)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [16] = {
+        [sym_declarator] = ACTIONS(SHIFT(35)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(36)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(38)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(39)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(41)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [17] = {
+        [sym_declarator] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [sym_pointer] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__type_specifier, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [18] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(16)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_struct_declaration] = ACTIONS(SHIFT(18)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(34)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_specifier_repeat1, 1)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [19] = {
-        [sym_identifier] = ACTIONS(SHIFT(32)),
+        [sym_identifier] = ACTIONS(SHIFT(33)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [20] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(32)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(31)),
     },
     [21] = {
-        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(24)),
+        [sym_identifier] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(24)),
     },
     [22] = {
-        [sym__init_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-    },
-    [23] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-    },
-    [24] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(15)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_struct_declaration] = ACTIONS(SHIFT(17)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(26)),
-    },
-    [25] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(27)),
-    },
-    [26] = {
-        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
-    },
-    [27] = {
-        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-    },
-    [28] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(15)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_struct_declaration] = ACTIONS(SHIFT(17)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(29)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(27)),
-    },
-    [29] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(30)),
-    },
-    [30] = {
-        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-    },
-    [31] = {
         [sym__init_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
         [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
         [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
         [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [23] = {
+        [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym_pointer] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [24] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(16)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_struct_declaration] = ACTIONS(SHIFT(18)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(30)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(31)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [25] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(26)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [26] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(16)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_struct_declaration] = ACTIONS(SHIFT(18)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(27)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(28)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [27] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(29)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [28] = {
+        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
         [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [29] = {
+        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [30] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(28)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [31] = {
+        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [32] = {
-        [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [sym_pointer] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_type_name, 2)),
-    },
-    [33] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_specifier_repeat1, 2)),
-    },
-    [34] = {
-        [sym__type_specifier] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [sym_type_name] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [sym_struct_specifier] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [sym_struct_declaration] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
-    },
-    [35] = {
-        [sym__type_specifier] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [sym_type_name] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [sym_struct_specifier] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [sym_struct_declaration] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(105)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(106)),
-    },
-    [36] = {
-        [sym__direct_declarator] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 1)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
-    },
-    [37] = {
-        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-    },
-    [38] = {
-        [sym__direct_declarator] = ACTIONS(SHIFT(104)),
-        [sym_identifier] = ACTIONS(SHIFT(37)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(39)),
-    },
-    [39] = {
-        [sym_declarator] = ACTIONS(SHIFT(41)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(42)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(43)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(45)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
-    },
-    [40] = {
-        [sym__direct_declarator] = ACTIONS(REDUCE(sym_pointer, 1)),
-        [sym_pointer] = ACTIONS(REDUCE(sym_pointer, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_pointer, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_pointer, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_pointer, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_pointer, 1)),
-    },
-    [41] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(103)),
-    },
-    [42] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_declarator, 1)),
-    },
-    [43] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-    },
-    [44] = {
-        [sym__direct_declarator] = ACTIONS(SHIFT(48)),
-        [sym_identifier] = ACTIONS(SHIFT(43)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(45)),
-    },
-    [45] = {
-        [sym_declarator] = ACTIONS(SHIFT(46)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(42)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(43)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(45)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
-    },
-    [46] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(47)),
-    },
-    [47] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-    },
-    [48] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_declarator, 2)),
-    },
-    [49] = {
-        [sym_expression] = ACTIONS(SHIFT(102)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(47)),
-    },
-    [50] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(51)),
-        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(52)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_parameter_declaration] = ACTIONS(SHIFT(53)),
-        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
-    },
-    [51] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(100)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-    },
-    [52] = {
-        [sym_declarator] = ACTIONS(SHIFT(60)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(61)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(62)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(63)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(64)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
-    },
-    [53] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(54)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(56)),
-    },
-    [54] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(59)),
-    },
-    [55] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(51)),
-        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(52)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_parameter_declaration] = ACTIONS(SHIFT(57)),
-        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
-    },
-    [56] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-    },
-    [57] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__direct_declarator_repeat1, 2)),
-    },
-    [58] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__direct_declarator_repeat1, 3)),
-    },
-    [59] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-    },
-    [60] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_parameter_declaration, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_parameter_declaration, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_parameter_declaration, 2)),
-    },
-    [61] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(69)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_declarator, 1)),
-    },
-    [62] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-    },
-    [63] = {
-        [sym__direct_declarator] = ACTIONS(SHIFT(67)),
-        [sym_identifier] = ACTIONS(SHIFT(62)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(64)),
-    },
-    [64] = {
-        [sym_declarator] = ACTIONS(SHIFT(65)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(42)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(43)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(45)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
-    },
-    [65] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(66)),
-    },
-    [66] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-    },
-    [67] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(69)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_declarator, 2)),
-    },
-    [68] = {
-        [sym_expression] = ACTIONS(SHIFT(74)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(66)),
-    },
-    [69] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(51)),
-        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(52)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_parameter_declaration] = ACTIONS(SHIFT(70)),
-        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
-    },
-    [70] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(71)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(72)),
-    },
-    [71] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(73)),
-    },
-    [72] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-    },
-    [73] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-    },
-    [74] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(72)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-    },
-    [75] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
-    },
-    [76] = {
-        [sym_expression] = ACTIONS(SHIFT(81)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(83)),
-    },
-    [77] = {
-        [sym_expression] = ACTIONS(SHIFT(80)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [78] = {
-        [sym_expression] = ACTIONS(SHIFT(79)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [79] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-    },
-    [80] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-    },
-    [81] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(84)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(85)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(87)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(88)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(89)),
-    },
-    [82] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
-    },
-    [83] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
-    },
-    [84] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(99)),
-    },
-    [85] = {
-        [sym_expression] = ACTIONS(SHIFT(97)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [86] = {
-        [sym_expression] = ACTIONS(SHIFT(92)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(93)),
-    },
-    [87] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
-    },
-    [88] = {
-        [sym_expression] = ACTIONS(SHIFT(91)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [89] = {
-        [sym_expression] = ACTIONS(SHIFT(90)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [90] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(88)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-    },
-    [91] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-    },
-    [92] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(85)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(95)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(88)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(89)),
-    },
-    [93] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
-    },
-    [94] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(96)),
-    },
-    [95] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
-    },
-    [96] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
-    },
-    [97] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(85)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_call_expression_repeat1, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(88)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(89)),
-    },
-    [98] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_call_expression_repeat1, 3)),
-    },
-    [99] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
-    },
-    [100] = {
-        [sym_declarator] = ACTIONS(SHIFT(101)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(61)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(62)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(63)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(64)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
-    },
-    [101] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_parameter_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_parameter_declaration, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_parameter_declaration, 3)),
-    },
-    [102] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-    },
-    [103] = {
-        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-    },
-    [104] = {
-        [sym__type_specifier] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [sym_type_name] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [sym_struct_specifier] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [sym_struct_declaration] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(105)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(106)),
-    },
-    [105] = {
-        [sym_expression] = ACTIONS(SHIFT(111)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(103)),
-    },
-    [106] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(51)),
-        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(52)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_parameter_declaration] = ACTIONS(SHIFT(107)),
-        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(103)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
-    },
-    [107] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(108)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(109)),
-    },
-    [108] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(110)),
-    },
-    [109] = {
-        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-    },
-    [110] = {
-        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-    },
-    [111] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(109)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-    },
-    [112] = {
-        [sym__direct_declarator] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 2)),
-    },
-    [113] = {
-        [sym__type_specifier] = ACTIONS(SHIFT(15)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
-        [sym_struct_declaration] = ACTIONS(SHIFT(17)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_struct_specifier_repeat1] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(31)),
-    },
-    [114] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(115)),
-    },
-    [115] = {
         [sym__init_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
         [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
         [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
         [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 5)),
+    },
+    [33] = {
+        [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [sym_pointer] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [34] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_specifier_repeat1, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [35] = {
+        [sym__type_specifier] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [sym_type_name] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [sym_struct_declaration] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_struct_declaration, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [36] = {
+        [sym__type_specifier] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_type_name] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_struct_declaration] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [37] = {
+        [sym__direct_declarator] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 1)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(113)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 1)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [38] = {
+        [sym__direct_declarator] = ACTIONS(SHIFT(105)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(39)),
+        [sym_identifier] = ACTIONS(SHIFT(41)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [39] = {
+        [sym_declarator] = ACTIONS(SHIFT(42)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(43)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [40] = {
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym_pointer, 1)),
+        [sym_pointer] = ACTIONS(REDUCE(sym_pointer, 1)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_pointer, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_pointer, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_pointer, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_pointer, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [41] = {
+        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [42] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(104)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [43] = {
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(50)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(51)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [44] = {
+        [sym__direct_declarator] = ACTIONS(SHIFT(49)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(45)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [45] = {
+        [sym_declarator] = ACTIONS(SHIFT(47)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(43)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [46] = {
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [47] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(48)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [48] = {
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [49] = {
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(50)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(51)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [50] = {
+        [sym_expression] = ACTIONS(SHIFT(103)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(48)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [51] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(52)),
+        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
+        [sym__type_specifier] = ACTIONS(SHIFT(53)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_parameter_declaration] = ACTIONS(SHIFT(54)),
+        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(48)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [52] = {
+        [sym__type_specifier] = ACTIONS(SHIFT(101)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [53] = {
+        [sym_declarator] = ACTIONS(SHIFT(61)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(62)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(63)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(64)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(65)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [54] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(55)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(56)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(57)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [55] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(60)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [56] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(52)),
+        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
+        [sym__type_specifier] = ACTIONS(SHIFT(53)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_parameter_declaration] = ACTIONS(SHIFT(58)),
+        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [57] = {
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [58] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(59)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(56)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__direct_declarator_repeat1, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [59] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__direct_declarator_repeat1, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [60] = {
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [61] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_parameter_declaration, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_parameter_declaration, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_parameter_declaration, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [62] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(69)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(70)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [63] = {
+        [sym__direct_declarator] = ACTIONS(SHIFT(68)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(64)),
+        [sym_identifier] = ACTIONS(SHIFT(65)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [64] = {
+        [sym_declarator] = ACTIONS(SHIFT(66)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(43)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [65] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [66] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(67)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [67] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [68] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(69)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(70)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [69] = {
+        [sym_expression] = ACTIONS(SHIFT(75)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(67)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [70] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(52)),
+        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
+        [sym__type_specifier] = ACTIONS(SHIFT(53)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_parameter_declaration] = ACTIONS(SHIFT(71)),
+        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(67)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [71] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(72)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(56)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(73)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [72] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(74)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [73] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [74] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [75] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(73)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(79)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [76] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [77] = {
+        [sym_expression] = ACTIONS(SHIFT(82)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(84)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [78] = {
+        [sym_expression] = ACTIONS(SHIFT(81)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [79] = {
+        [sym_expression] = ACTIONS(SHIFT(80)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [80] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [81] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [82] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(85)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(86)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(88)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(89)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(90)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [83] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [84] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [85] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(100)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [86] = {
+        [sym_expression] = ACTIONS(SHIFT(98)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [87] = {
+        [sym_expression] = ACTIONS(SHIFT(93)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(94)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [88] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [89] = {
+        [sym_expression] = ACTIONS(SHIFT(92)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [90] = {
+        [sym_expression] = ACTIONS(SHIFT(91)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [91] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(89)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [92] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [93] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(95)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(86)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(96)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(89)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(90)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [94] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [95] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(97)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [96] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [97] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [98] = {
+        [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(99)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(86)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_call_expression_repeat1, 2)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(89)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(90)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [99] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_call_expression_repeat1, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [100] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [101] = {
+        [sym_declarator] = ACTIONS(SHIFT(102)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(62)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(63)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(64)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(65)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [102] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(REDUCE(sym_parameter_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_parameter_declaration, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_parameter_declaration, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [103] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(57)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(79)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [104] = {
+        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [105] = {
+        [sym__type_specifier] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_type_name] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_struct_declaration] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [106] = {
+        [sym_expression] = ACTIONS(SHIFT(112)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(104)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [107] = {
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(52)),
+        [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
+        [sym__type_specifier] = ACTIONS(SHIFT(53)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
+        [sym_parameter_declaration] = ACTIONS(SHIFT(108)),
+        [sym_type_qualifier] = ACTIONS(SHIFT(4)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(104)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [108] = {
+        [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(109)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(56)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(110)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [109] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(111)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [110] = {
+        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [111] = {
+        [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_type_name] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_struct_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_struct_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_struct_specifier_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [112] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(110)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(79)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [113] = {
+        [sym__direct_declarator] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(aux_sym_declarator_repeat1, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [114] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(22)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [115] = {
+        [sym__init_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym__direct_declarator] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym_pointer] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_struct_specifier, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [116] = {
         [sym_identifier] = ACTIONS(REDUCE(aux_sym_type_name_repeat1, 2)),
@@ -3418,17 +3418,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 2)),
         [sym_pointer] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_type_name, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_type_name, 2)),
         [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_type_name, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_type_name, 2)),
     },
     [118] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(257)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(238)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(258)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(238)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(258)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [119] = {
         [sym_declaration_specifiers] = ACTIONS(SHIFT(134)),
@@ -3439,28 +3439,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(SHIFT(136)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
         [sym_compound_statement] = ACTIONS(SHIFT(137)),
-        [sym_identifier] = ACTIONS(SHIFT(7)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(138)),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(139)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(140)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(12)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [120] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declarator, 1)),
@@ -3471,32 +3471,48 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym_declarator, 1)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym_declarator, 1)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(127)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(128)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(127)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(128)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [121] = {
+        [sym__direct_declarator] = ACTIONS(SHIFT(126)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(122)),
+        [sym_identifier] = ACTIONS(SHIFT(123)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [122] = {
+        [sym_declarator] = ACTIONS(SHIFT(124)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(43)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [123] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_storage_class_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym__type_specifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
@@ -3505,50 +3521,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-    },
-    [122] = {
-        [sym__direct_declarator] = ACTIONS(SHIFT(126)),
-        [sym_identifier] = ACTIONS(SHIFT(121)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(123)),
-    },
-    [123] = {
-        [sym_declarator] = ACTIONS(SHIFT(124)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(42)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(43)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(45)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [124] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(125)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(125)),
     },
     [125] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
@@ -3559,30 +3559,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [126] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declarator, 2)),
@@ -3593,76 +3593,76 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym_declarator, 2)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym_declarator, 2)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(127)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(128)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(127)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(128)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [127] = {
         [sym_expression] = ACTIONS(SHIFT(133)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(125)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(125)),
     },
     [128] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(51)),
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(52)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(52)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
+        [sym__type_specifier] = ACTIONS(SHIFT(53)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
         [sym_parameter_declaration] = ACTIONS(SHIFT(129)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(125)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(125)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [129] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(130)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(131)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(56)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(131)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [130] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(132)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(132)),
     },
     [131] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
@@ -3673,30 +3673,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [132] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
@@ -3707,61 +3707,61 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [133] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(131)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(79)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(131)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
     },
     [134] = {
         [sym__type_specifier] = ACTIONS(SHIFT(253)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_identifier] = ACTIONS(SHIFT(7)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [sym_identifier] = ACTIONS(SHIFT(12)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
     },
     [135] = {
         [sym__init_declarator] = ACTIONS(SHIFT(249)),
         [sym_declarator] = ACTIONS(SHIFT(222)),
         [sym__direct_declarator] = ACTIONS(SHIFT(223)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(224)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(224)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(225)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(226)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [136] = {
         [sym_declaration_specifiers] = ACTIONS(SHIFT(134)),
@@ -3772,24 +3772,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(SHIFT(136)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
         [sym_compound_statement] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 1)),
-        [sym_identifier] = ACTIONS(SHIFT(7)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(248)),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 1)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 1)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(12)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [137] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_function_definition, 3)),
@@ -3797,8 +3797,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [138] = {
         [sym_compound_statement] = ACTIONS(SHIFT(247)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(139)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(139)),
     },
     [139] = {
         [sym_declaration_specifiers] = ACTIONS(SHIFT(199)),
@@ -3813,61 +3813,61 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_call_expression] = ACTIONS(SHIFT(203)),
         [sym_statement] = ACTIONS(SHIFT(201)),
         [sym_expression_statement] = ACTIONS(SHIFT(204)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(205)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(206)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
         [sym_string] = ACTIONS(SHIFT(203)),
-        [sym_identifier] = ACTIONS(SHIFT(205)),
+        [sym_identifier] = ACTIONS(SHIFT(207)),
         [sym_number] = ACTIONS(SHIFT(203)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
     },
     [140] = {
         [sym_initializer] = ACTIONS(SHIFT(141)),
         [sym_expression] = ACTIONS(SHIFT(142)),
         [sym_math_expression] = ACTIONS(SHIFT(143)),
         [sym_call_expression] = ACTIONS(SHIFT(143)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(144)),
         [sym_string] = ACTIONS(SHIFT(143)),
         [sym_identifier] = ACTIONS(SHIFT(143)),
         [sym_number] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(144)),
     },
     [141] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [142] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(191)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_initializer, 1)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(189)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(190)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(191)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [143] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [144] = {
         [sym_initializer] = ACTIONS(SHIFT(145)),
@@ -3876,50 +3876,50 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_expression] = ACTIONS(SHIFT(148)),
         [sym_math_expression] = ACTIONS(SHIFT(149)),
         [sym_call_expression] = ACTIONS(SHIFT(149)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(150)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(151)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(152)),
         [sym_string] = ACTIONS(SHIFT(149)),
         [sym_identifier] = ACTIONS(SHIFT(149)),
         [sym_number] = ACTIONS(SHIFT(149)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(150)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(152)),
     },
     [145] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 1)),
     },
     [146] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(186)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(187)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(187)),
     },
     [147] = {
         [sym_initializer] = ACTIONS(SHIFT(185)),
         [sym_expression] = ACTIONS(SHIFT(148)),
         [sym_math_expression] = ACTIONS(SHIFT(149)),
         [sym_call_expression] = ACTIONS(SHIFT(149)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(150)),
         [sym_string] = ACTIONS(SHIFT(149)),
         [sym_identifier] = ACTIONS(SHIFT(149)),
         [sym_number] = ACTIONS(SHIFT(149)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(150)),
     },
     [148] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 1)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(175)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(176)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(177)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(175)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(176)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(177)),
     },
     [149] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
     },
     [150] = {
         [sym_initializer] = ACTIONS(SHIFT(145)),
@@ -3928,21 +3928,21 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_expression] = ACTIONS(SHIFT(148)),
         [sym_math_expression] = ACTIONS(SHIFT(149)),
         [sym_call_expression] = ACTIONS(SHIFT(149)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(150)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(151)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(152)),
         [sym_string] = ACTIONS(SHIFT(149)),
         [sym_identifier] = ACTIONS(SHIFT(149)),
         [sym_number] = ACTIONS(SHIFT(149)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(150)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(152)),
     },
     [151] = {
         [sym_expression] = ACTIONS(SHIFT(164)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [152] = {
@@ -3950,34 +3950,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [153] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_designation_repeat1] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(157)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(155)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(156)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(157)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [154] = {
+        [aux_sym_EQ] = ACTIONS(SHIFT(163)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(163)),
     },
     [155] = {
         [sym_initializer] = ACTIONS(REDUCE(sym_designation, 3)),
         [sym_expression] = ACTIONS(REDUCE(sym_designation, 3)),
         [sym_math_expression] = ACTIONS(REDUCE(sym_designation, 3)),
         [sym_call_expression] = ACTIONS(REDUCE(sym_designation, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_designation, 3)),
         [sym_string] = ACTIONS(REDUCE(sym_designation, 3)),
         [sym_identifier] = ACTIONS(REDUCE(sym_designation, 3)),
         [sym_number] = ACTIONS(REDUCE(sym_designation, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_designation, 3)),
     },
     [156] = {
         [sym_expression] = ACTIONS(SHIFT(160)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [157] = {
@@ -3985,83 +3985,83 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [158] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_designation_repeat1] = ACTIONS(SHIFT(159)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(157)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(156)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(157)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [159] = {
+        [aux_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
     },
     [160] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(161)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(79)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(161)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
     },
     [161] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_designation_repeat1] = ACTIONS(SHIFT(162)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(157)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(156)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(157)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [162] = {
+        [aux_sym_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(aux_sym_designation_repeat1, 4)),
     },
     [163] = {
         [sym_initializer] = ACTIONS(REDUCE(sym_designation, 4)),
         [sym_expression] = ACTIONS(REDUCE(sym_designation, 4)),
         [sym_math_expression] = ACTIONS(REDUCE(sym_designation, 4)),
         [sym_call_expression] = ACTIONS(REDUCE(sym_designation, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_designation, 4)),
         [sym_string] = ACTIONS(REDUCE(sym_designation, 4)),
         [sym_identifier] = ACTIONS(REDUCE(sym_designation, 4)),
         [sym_number] = ACTIONS(REDUCE(sym_designation, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_designation, 4)),
     },
     [164] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(165)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(79)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(165)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
     },
     [165] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_designation_repeat1] = ACTIONS(SHIFT(166)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(163)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(157)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(163)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(156)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(157)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [166] = {
+        [aux_sym_EQ] = ACTIONS(SHIFT(167)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(167)),
     },
     [167] = {
         [sym_initializer] = ACTIONS(REDUCE(sym_designation, 5)),
         [sym_expression] = ACTIONS(REDUCE(sym_designation, 5)),
         [sym_math_expression] = ACTIONS(REDUCE(sym_designation, 5)),
         [sym_call_expression] = ACTIONS(REDUCE(sym_designation, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_designation, 5)),
         [sym_string] = ACTIONS(REDUCE(sym_designation, 5)),
         [sym_identifier] = ACTIONS(REDUCE(sym_designation, 5)),
         [sym_number] = ACTIONS(REDUCE(sym_designation, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_designation, 5)),
     },
     [168] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(169)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(170)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(169)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(170)),
     },
     [169] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_initializer, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer, 3)),
     },
     [170] = {
         [sym_initializer] = ACTIONS(SHIFT(171)),
@@ -4069,50 +4069,50 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_expression] = ACTIONS(SHIFT(148)),
         [sym_math_expression] = ACTIONS(SHIFT(149)),
         [sym_call_expression] = ACTIONS(SHIFT(149)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(150)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(173)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(151)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(152)),
         [sym_string] = ACTIONS(SHIFT(149)),
         [sym_identifier] = ACTIONS(SHIFT(149)),
         [sym_number] = ACTIONS(SHIFT(149)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(150)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(173)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(152)),
     },
     [171] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 3)),
     },
     [172] = {
         [sym_initializer] = ACTIONS(SHIFT(174)),
         [sym_expression] = ACTIONS(SHIFT(148)),
         [sym_math_expression] = ACTIONS(SHIFT(149)),
         [sym_call_expression] = ACTIONS(SHIFT(149)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(150)),
         [sym_string] = ACTIONS(SHIFT(149)),
         [sym_identifier] = ACTIONS(SHIFT(149)),
         [sym_number] = ACTIONS(SHIFT(149)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(150)),
     },
     [173] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_initializer, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer, 4)),
     },
     [174] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 4)),
     },
     [175] = {
         [sym_expression] = ACTIONS(SHIFT(180)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(181)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(181)),
     },
     [176] = {
         [sym_expression] = ACTIONS(SHIFT(179)),
@@ -4133,68 +4133,68 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [178] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(175)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(176)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(175)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(176)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
     },
     [179] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(175)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(175)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
     },
     [180] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(182)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(85)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(183)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(88)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(86)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(183)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(89)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(90)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [181] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
     },
     [182] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(184)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(184)),
     },
     [183] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
     },
     [184] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
     },
     [185] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_initializer_list, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer_list, 2)),
     },
     [186] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_initializer, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_initializer, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_initializer, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [187] = {
         [sym_initializer] = ACTIONS(SHIFT(171)),
@@ -4202,30 +4202,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_expression] = ACTIONS(SHIFT(148)),
         [sym_math_expression] = ACTIONS(SHIFT(149)),
         [sym_call_expression] = ACTIONS(SHIFT(149)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(150)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(188)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(151)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(152)),
         [sym_string] = ACTIONS(SHIFT(149)),
         [sym_identifier] = ACTIONS(SHIFT(149)),
         [sym_number] = ACTIONS(SHIFT(149)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(150)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(188)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(152)),
     },
     [188] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_initializer, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_initializer, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_initializer, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_initializer, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_initializer, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [189] = {
         [sym_expression] = ACTIONS(SHIFT(194)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(195)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(195)),
     },
     [190] = {
         [sym_expression] = ACTIONS(SHIFT(193)),
@@ -4246,86 +4246,86 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [192] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(189)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(190)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [193] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(189)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [194] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(85)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(88)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(86)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(197)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(89)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(90)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [195] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [196] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(198)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(198)),
     },
     [197] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [198] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [199] = {
         [sym__type_specifier] = ACTIONS(SHIFT(243)),
         [sym_type_name] = ACTIONS(SHIFT(6)),
         [sym_struct_specifier] = ACTIONS(SHIFT(6)),
-        [sym_identifier] = ACTIONS(SHIFT(7)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [sym_identifier] = ACTIONS(SHIFT(12)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
     },
     [200] = {
         [sym__init_declarator] = ACTIONS(SHIFT(221)),
         [sym_declarator] = ACTIONS(SHIFT(222)),
         [sym__direct_declarator] = ACTIONS(SHIFT(223)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(224)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(224)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(225)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(226)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [201] = {
         [sym_declaration_specifiers] = ACTIONS(SHIFT(199)),
@@ -4340,40 +4340,40 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_call_expression] = ACTIONS(SHIFT(203)),
         [sym_statement] = ACTIONS(SHIFT(201)),
         [sym_expression_statement] = ACTIONS(SHIFT(204)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(220)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_compound_statement_repeat1, 1)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
         [sym_string] = ACTIONS(SHIFT(203)),
-        [sym_identifier] = ACTIONS(SHIFT(205)),
+        [sym_identifier] = ACTIONS(SHIFT(207)),
         [sym_number] = ACTIONS(SHIFT(203)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_compound_statement_repeat1, 1)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
     },
     [202] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(209)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(210)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(211)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(212)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(209)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(210)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(212)),
     },
     [203] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
     },
     [204] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_statement, 1)),
@@ -4388,46 +4388,46 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_call_expression] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_statement] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_statement, 1)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_string] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_identifier] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_number] = ACTIONS(REDUCE(sym_statement, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_statement, 1)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_statement, 1)),
     },
     [205] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(208)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [206] = {
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_compound_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [207] = {
         [sym__init_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__direct_declarator] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_pointer] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declarator_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_type_name, 1), REDUCE(sym_expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_type_name, 1), REDUCE(sym_expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
-    },
-    [206] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(208)),
-    },
-    [207] = {
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_compound_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_type_name, 1), REDUCE(sym_expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_type_name, 1), REDUCE(sym_expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_expression, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [208] = {
@@ -4447,36 +4447,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_call_expression] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_identifier] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_number] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_expression_statement, 2)),
     },
     [210] = {
         [sym_expression] = ACTIONS(SHIFT(215)),
-        [sym_math_expression] = ACTIONS(SHIFT(82)),
-        [sym_call_expression] = ACTIONS(SHIFT(82)),
-        [sym_string] = ACTIONS(SHIFT(82)),
-        [sym_identifier] = ACTIONS(SHIFT(82)),
-        [sym_number] = ACTIONS(SHIFT(82)),
+        [sym_math_expression] = ACTIONS(SHIFT(83)),
+        [sym_call_expression] = ACTIONS(SHIFT(83)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(216)),
+        [sym_string] = ACTIONS(SHIFT(83)),
+        [sym_identifier] = ACTIONS(SHIFT(83)),
+        [sym_number] = ACTIONS(SHIFT(83)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(216)),
     },
     [211] = {
         [sym_expression] = ACTIONS(SHIFT(214)),
@@ -4497,211 +4497,211 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [213] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(210)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(211)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(210)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
     },
     [214] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(210)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(210)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_expression, 3)),
     },
     [215] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_call_expression_repeat1] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(85)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(88)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(86)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(218)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(89)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(90)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [216] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
     },
     [217] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(219)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(219)),
     },
     [218] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
     },
     [219] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
     },
     [220] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_compound_statement_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_compound_statement_repeat1, 2)),
     },
     [221] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(237)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(238)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(239)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(238)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(239)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [222] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(140)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(140)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [223] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(230)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(231)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(230)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(231)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [224] = {
+        [sym__direct_declarator] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(225)),
+        [sym_identifier] = ACTIONS(SHIFT(226)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
     },
     [225] = {
-        [sym__direct_declarator] = ACTIONS(SHIFT(229)),
-        [sym_identifier] = ACTIONS(SHIFT(224)),
+        [sym_declarator] = ACTIONS(SHIFT(227)),
+        [sym__direct_declarator] = ACTIONS(SHIFT(43)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(226)),
     },
     [226] = {
-        [sym_declarator] = ACTIONS(SHIFT(227)),
-        [sym__direct_declarator] = ACTIONS(SHIFT(42)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(43)),
+        [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(44)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(45)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [227] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(228)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(228)),
     },
     [228] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [229] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_declarator, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(230)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(231)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_declarator, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(230)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(231)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [230] = {
         [sym_expression] = ACTIONS(SHIFT(236)),
-        [sym_math_expression] = ACTIONS(SHIFT(75)),
-        [sym_call_expression] = ACTIONS(SHIFT(75)),
-        [sym_string] = ACTIONS(SHIFT(75)),
-        [sym_identifier] = ACTIONS(SHIFT(75)),
-        [sym_number] = ACTIONS(SHIFT(75)),
+        [sym_math_expression] = ACTIONS(SHIFT(76)),
+        [sym_call_expression] = ACTIONS(SHIFT(76)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(228)),
+        [sym_string] = ACTIONS(SHIFT(76)),
+        [sym_identifier] = ACTIONS(SHIFT(76)),
+        [sym_number] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(228)),
     },
     [231] = {
-        [sym_declaration_specifiers] = ACTIONS(SHIFT(51)),
+        [sym_declaration_specifiers] = ACTIONS(SHIFT(52)),
         [sym_storage_class_specifier] = ACTIONS(SHIFT(4)),
-        [sym__type_specifier] = ACTIONS(SHIFT(52)),
-        [sym_type_name] = ACTIONS(SHIFT(16)),
-        [sym_struct_specifier] = ACTIONS(SHIFT(16)),
+        [sym__type_specifier] = ACTIONS(SHIFT(53)),
+        [sym_type_name] = ACTIONS(SHIFT(17)),
+        [sym_struct_specifier] = ACTIONS(SHIFT(17)),
         [sym_parameter_declaration] = ACTIONS(SHIFT(232)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(18)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(228)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(21)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(228)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(23)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [232] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym__direct_declarator_repeat1] = ACTIONS(SHIFT(233)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(234)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(56)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(234)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [233] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(235)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(235)),
     },
     [234] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [235] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__direct_declarator, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [236] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(234)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(77)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(78)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(79)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(234)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
     },
     [237] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(242)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(242)),
     },
     [238] = {
         [sym__init_declarator] = ACTIONS(SHIFT(240)),
         [sym_declarator] = ACTIONS(SHIFT(222)),
         [sym__direct_declarator] = ACTIONS(SHIFT(223)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(224)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(224)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(225)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(226)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [239] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 3)),
@@ -4716,36 +4716,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_call_expression] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_statement] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_string] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_number] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declaration, 3)),
     },
     [240] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(241)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(238)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(aux_sym_declaration_repeat1, 2)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(238)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(aux_sym_declaration_repeat1, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [241] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(aux_sym_declaration_repeat1, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(aux_sym_declaration_repeat1, 3)),
     },
     [242] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 4)),
@@ -4760,47 +4760,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_call_expression] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_statement] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_string] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_number] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declaration, 4)),
     },
     [243] = {
         [sym__init_declarator] = ACTIONS(SHIFT(244)),
         [sym_declarator] = ACTIONS(SHIFT(222)),
         [sym__direct_declarator] = ACTIONS(SHIFT(223)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(224)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(224)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(225)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(226)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [244] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(245)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(238)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(242)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(238)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(242)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [245] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(246)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(246)),
     },
     [246] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 5)),
@@ -4815,26 +4815,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_call_expression] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_statement] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_string] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_number] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_compound_statement_repeat1] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declaration, 5)),
     },
     [247] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_function_definition, 4)),
@@ -4842,18 +4842,18 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [248] = {
         [sym_compound_statement] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(aux_sym_function_definition_repeat1, 2)),
     },
     [249] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(250)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(238)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(251)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(238)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(251)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [250] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(252)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(252)),
     },
     [251] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 3)),
@@ -4864,24 +4864,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym_declaration, 3)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym_declaration, 3)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declaration, 3)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [252] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 4)),
@@ -4892,45 +4892,45 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym_declaration, 4)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym_declaration, 4)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declaration, 4)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [253] = {
         [sym__init_declarator] = ACTIONS(SHIFT(254)),
         [sym_declarator] = ACTIONS(SHIFT(222)),
         [sym__direct_declarator] = ACTIONS(SHIFT(223)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(224)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(224)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(225)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(226)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [254] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(255)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(238)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(252)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(238)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(252)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [255] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(256)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(256)),
     },
     [256] = {
         [sym_declaration_specifiers] = ACTIONS(REDUCE(sym_declaration, 5)),
@@ -4941,28 +4941,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_type_qualifier] = ACTIONS(REDUCE(sym_declaration, 5)),
         [sym_compound_statement] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(REDUCE(sym_declaration, 5)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_typedef] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_extern] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_static] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_auto] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_register] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_const] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_restrict] = ACTIONS(REDUCE(sym_declaration, 5)),
-        [aux_sym_STR_volatile] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_typedef] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_extern] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_static] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_auto] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_register] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_const] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_restrict] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [aux_sym_volatile] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_declaration, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [257] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(259)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
     },
     [258] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_declaration, 3)),
@@ -4978,66 +4978,66 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_name] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
         [sym_struct_specifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
         [sym_type_qualifier] = ACTIONS(SHIFT(260)),
-        [sym_identifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_specifiers_repeat1] = ACTIONS(SHIFT(262)),
         [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
+        [aux_sym_long] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
+        [aux_sym_short] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [261] = {
         [sym__type_specifier] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
         [sym_type_name] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
         [sym_struct_specifier] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
+        [aux_sym_signed] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
+        [aux_sym_long] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
+        [aux_sym_short] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
         [sym_identifier] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_declaration_specifiers, 2)),
     },
     [262] = {
         [sym__type_specifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
         [sym_type_name] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
         [sym_struct_specifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
+        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
+        [aux_sym_signed] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
+        [aux_sym_unsigned] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
+        [aux_sym_long] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
+        [aux_sym_short] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
+        [aux_sym_struct] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
         [sym_identifier] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_type_name_repeat1] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
-        [aux_sym_STR_signed] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
-        [aux_sym_STR_unsigned] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
-        [aux_sym_STR_long] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
-        [aux_sym_STR_short] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(aux_sym_declaration_specifiers_repeat1, 2)),
     },
     [263] = {
         [sym__init_declarator] = ACTIONS(SHIFT(264)),
         [sym_declarator] = ACTIONS(SHIFT(265)),
         [sym__direct_declarator] = ACTIONS(SHIFT(120)),
-        [sym_pointer] = ACTIONS(SHIFT(36)),
-        [sym_identifier] = ACTIONS(SHIFT(121)),
+        [sym_pointer] = ACTIONS(SHIFT(37)),
+        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(121)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(122)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(40)),
+        [sym_identifier] = ACTIONS(SHIFT(123)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_declarator_repeat1] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(40)),
     },
     [264] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_declaration_repeat1] = ACTIONS(SHIFT(268)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(238)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(238)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(259)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [265] = {
         [sym_declaration_specifiers] = ACTIONS(SHIFT(134)),
@@ -5048,41 +5048,41 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_declaration] = ACTIONS(SHIFT(136)),
         [sym_type_qualifier] = ACTIONS(SHIFT(4)),
         [sym_compound_statement] = ACTIONS(SHIFT(247)),
-        [sym_identifier] = ACTIONS(SHIFT(7)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_function_definition_repeat1] = ACTIONS(SHIFT(266)),
-        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(8)),
+        [aux_sym_type_name_repeat1] = ACTIONS(SHIFT(7)),
         [aux_sym_declaration_repeat1] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_typedef] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_extern] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_static] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_auto] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_register] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_signed] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_unsigned] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_long] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_short] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_const] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_restrict] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_volatile] = ACTIONS(SHIFT(12)),
+        [aux_sym_typedef] = ACTIONS(SHIFT(8)),
+        [aux_sym_extern] = ACTIONS(SHIFT(8)),
+        [aux_sym_static] = ACTIONS(SHIFT(8)),
+        [aux_sym_auto] = ACTIONS(SHIFT(8)),
+        [aux_sym_register] = ACTIONS(SHIFT(8)),
+        [aux_sym_signed] = ACTIONS(SHIFT(9)),
+        [aux_sym_unsigned] = ACTIONS(SHIFT(9)),
+        [aux_sym_long] = ACTIONS(SHIFT(9)),
+        [aux_sym_short] = ACTIONS(SHIFT(9)),
+        [aux_sym_struct] = ACTIONS(SHIFT(10)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(139)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__init_declarator, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__init_declarator, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(140)),
+        [aux_sym_const] = ACTIONS(SHIFT(11)),
+        [aux_sym_restrict] = ACTIONS(SHIFT(11)),
+        [aux_sym_volatile] = ACTIONS(SHIFT(11)),
+        [sym_identifier] = ACTIONS(SHIFT(12)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [266] = {
         [sym_compound_statement] = ACTIONS(SHIFT(267)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(139)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(139)),
     },
     [267] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_function_definition, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [268] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(269)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(269)),
     },
     [269] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_declaration, 5)),
diff --git a/spec/fixtures/parsers/golang.c b/spec/fixtures/parsers/golang.c
index 1931c098..6974ec3d 100644
--- a/spec/fixtures/parsers/golang.c
+++ b/spec/fixtures/parsers/golang.c
@@ -34,11 +34,6 @@ enum {
     sym_package_name,
     sym_var_name,
     sym_type_name,
-    sym__line_break,
-    sym_string,
-    sym__identifier,
-    sym_number,
-    sym_comment,
     aux_sym_program_repeat1,
     aux_sym_program_repeat2,
     aux_sym_imports_block_repeat1,
@@ -50,42 +45,47 @@ enum {
     aux_sym__func_signature_repeat1,
     aux_sym__func_signature_repeat2,
     aux_sym__func_signature_repeat3,
-    aux_sym_STR_package,
-    aux_sym_STR_import,
-    aux_sym_STR_LPAREN,
-    aux_sym_STR_RPAREN,
-    aux_sym_STR_type,
-    aux_sym_STR_SEMI,
-    aux_sym_STR_var,
-    aux_sym_STR_EQ,
-    aux_sym_STR_func,
-    aux_sym_STR_LBRACE,
-    aux_sym_STR_RBRACE,
-    aux_sym_STR_STAR,
-    aux_sym_STR_map,
-    aux_sym_STR_LBRACK,
-    aux_sym_STR_RBRACK,
-    aux_sym_STR_struct,
-    aux_sym_STR_interface,
-    aux_sym_STR_return,
-    aux_sym_STR_COMMA,
-    aux_sym_STR_COLON_EQ,
-    aux_sym_STR_for,
-    aux_sym_STR_range,
-    aux_sym_STR_if,
-    aux_sym_STR_else,
-    aux_sym_STR_DOT,
-    aux_sym_STR_SLASH,
-    aux_sym_STR_PLUS,
-    aux_sym_STR_DASH,
-    aux_sym_STR_PIPE_PIPE,
-    aux_sym_STR_AMP_AMP,
-    aux_sym_STR_EQ_EQ,
-    aux_sym_STR_LT_EQ,
-    aux_sym_STR_LT,
-    aux_sym_STR_GT_EQ,
-    aux_sym_STR_GT,
-    aux_sym_STR_BANG,
+    aux_sym_package,
+    aux_sym_import,
+    aux_sym_LPAREN,
+    aux_sym_RPAREN,
+    aux_sym_type,
+    aux_sym_SEMI,
+    aux_sym_var,
+    aux_sym_EQ,
+    aux_sym_func,
+    aux_sym_LBRACE,
+    aux_sym_RBRACE,
+    aux_sym_STAR,
+    aux_sym_map,
+    aux_sym_LBRACK,
+    aux_sym_RBRACK,
+    aux_sym_struct,
+    aux_sym_interface,
+    aux_sym_return,
+    aux_sym_COMMA,
+    aux_sym_COLON_EQ,
+    aux_sym_for,
+    aux_sym_range,
+    aux_sym_if,
+    aux_sym_else,
+    aux_sym_DOT,
+    aux_sym_SLASH,
+    aux_sym_PLUS,
+    aux_sym_DASH,
+    aux_sym_PIPE_PIPE,
+    aux_sym_AMP_AMP,
+    aux_sym_EQ_EQ,
+    aux_sym_LT_EQ,
+    aux_sym_LT,
+    aux_sym_GT_EQ,
+    aux_sym_GT,
+    aux_sym_BANG,
+    sym__line_break,
+    sym_string,
+    sym__identifier,
+    sym_number,
+    sym_comment,
 };
 
 static const char *ts_symbol_names[] = {
@@ -119,13 +119,6 @@ static const char *ts_symbol_names[] = {
     [sym_package_name] = "package_name",
     [sym_var_name] = "var_name",
     [sym_type_name] = "type_name",
-    [ts_builtin_sym_error] = "ERROR",
-    [ts_builtin_sym_end] = "END",
-    [sym__line_break] = "_line_break",
-    [sym_string] = "string",
-    [sym__identifier] = "_identifier",
-    [sym_number] = "number",
-    [sym_comment] = "comment",
     [aux_sym_program_repeat1] = "program_repeat1",
     [aux_sym_program_repeat2] = "program_repeat2",
     [aux_sym_imports_block_repeat1] = "imports_block_repeat1",
@@ -137,42 +130,49 @@ static const char *ts_symbol_names[] = {
     [aux_sym__func_signature_repeat1] = "_func_signature_repeat1",
     [aux_sym__func_signature_repeat2] = "_func_signature_repeat2",
     [aux_sym__func_signature_repeat3] = "_func_signature_repeat3",
-    [aux_sym_STR_package] = "STR_package",
-    [aux_sym_STR_import] = "STR_import",
-    [aux_sym_STR_LPAREN] = "STR_(",
-    [aux_sym_STR_RPAREN] = "STR_)",
-    [aux_sym_STR_type] = "STR_type",
-    [aux_sym_STR_SEMI] = "STR_;",
-    [aux_sym_STR_var] = "STR_var",
-    [aux_sym_STR_EQ] = "STR_=",
-    [aux_sym_STR_func] = "STR_func",
-    [aux_sym_STR_LBRACE] = "STR_{",
-    [aux_sym_STR_RBRACE] = "STR_}",
-    [aux_sym_STR_STAR] = "STR_*",
-    [aux_sym_STR_map] = "STR_map",
-    [aux_sym_STR_LBRACK] = "STR_[",
-    [aux_sym_STR_RBRACK] = "STR_]",
-    [aux_sym_STR_struct] = "STR_struct",
-    [aux_sym_STR_interface] = "STR_interface",
-    [aux_sym_STR_return] = "STR_return",
-    [aux_sym_STR_COMMA] = "STR_,",
-    [aux_sym_STR_COLON_EQ] = "STR_:=",
-    [aux_sym_STR_for] = "STR_for",
-    [aux_sym_STR_range] = "STR_range",
-    [aux_sym_STR_if] = "STR_if",
-    [aux_sym_STR_else] = "STR_else",
-    [aux_sym_STR_DOT] = "STR_.",
-    [aux_sym_STR_SLASH] = "STR_/",
-    [aux_sym_STR_PLUS] = "STR_+",
-    [aux_sym_STR_DASH] = "STR_-",
-    [aux_sym_STR_PIPE_PIPE] = "STR_||",
-    [aux_sym_STR_AMP_AMP] = "STR_&&",
-    [aux_sym_STR_EQ_EQ] = "STR_==",
-    [aux_sym_STR_LT_EQ] = "STR_<=",
-    [aux_sym_STR_LT] = "STR_<",
-    [aux_sym_STR_GT_EQ] = "STR_>=",
-    [aux_sym_STR_GT] = "STR_>",
-    [aux_sym_STR_BANG] = "STR_!",
+    [ts_builtin_sym_error] = "ERROR",
+    [ts_builtin_sym_end] = "END",
+    [aux_sym_package] = "package",
+    [aux_sym_import] = "import",
+    [aux_sym_LPAREN] = "(",
+    [aux_sym_RPAREN] = ")",
+    [aux_sym_type] = "type",
+    [aux_sym_SEMI] = ";",
+    [aux_sym_var] = "var",
+    [aux_sym_EQ] = "=",
+    [aux_sym_func] = "func",
+    [aux_sym_LBRACE] = "{",
+    [aux_sym_RBRACE] = "}",
+    [aux_sym_STAR] = "*",
+    [aux_sym_map] = "map",
+    [aux_sym_LBRACK] = "[",
+    [aux_sym_RBRACK] = "]",
+    [aux_sym_struct] = "struct",
+    [aux_sym_interface] = "interface",
+    [aux_sym_return] = "return",
+    [aux_sym_COMMA] = ",",
+    [aux_sym_COLON_EQ] = ":=",
+    [aux_sym_for] = "for",
+    [aux_sym_range] = "range",
+    [aux_sym_if] = "if",
+    [aux_sym_else] = "else",
+    [aux_sym_DOT] = ".",
+    [aux_sym_SLASH] = "/",
+    [aux_sym_PLUS] = "+",
+    [aux_sym_DASH] = "-",
+    [aux_sym_PIPE_PIPE] = "||",
+    [aux_sym_AMP_AMP] = "&&",
+    [aux_sym_EQ_EQ] = "==",
+    [aux_sym_LT_EQ] = "<=",
+    [aux_sym_LT] = "<",
+    [aux_sym_GT_EQ] = ">=",
+    [aux_sym_GT] = ">",
+    [aux_sym_BANG] = "!",
+    [sym__line_break] = "_line_break",
+    [sym_string] = "string",
+    [sym__identifier] = "_identifier",
+    [sym_number] = "number",
+    [sym_comment] = "comment",
 };
 
 static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
@@ -181,8 +181,6 @@ static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
     [sym__statement] = 1,
     [sym__expression] = 1,
     [sym__func_signature] = 1,
-    [sym__line_break] = 1,
-    [sym__identifier] = 1,
     [aux_sym_program_repeat1] = 1,
     [aux_sym_program_repeat2] = 1,
     [aux_sym_imports_block_repeat1] = 1,
@@ -194,42 +192,44 @@ static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
     [aux_sym__func_signature_repeat1] = 1,
     [aux_sym__func_signature_repeat2] = 1,
     [aux_sym__func_signature_repeat3] = 1,
-    [aux_sym_STR_package] = 1,
-    [aux_sym_STR_import] = 1,
-    [aux_sym_STR_LPAREN] = 1,
-    [aux_sym_STR_RPAREN] = 1,
-    [aux_sym_STR_type] = 1,
-    [aux_sym_STR_SEMI] = 1,
-    [aux_sym_STR_var] = 1,
-    [aux_sym_STR_EQ] = 1,
-    [aux_sym_STR_func] = 1,
-    [aux_sym_STR_LBRACE] = 1,
-    [aux_sym_STR_RBRACE] = 1,
-    [aux_sym_STR_STAR] = 1,
-    [aux_sym_STR_map] = 1,
-    [aux_sym_STR_LBRACK] = 1,
-    [aux_sym_STR_RBRACK] = 1,
-    [aux_sym_STR_struct] = 1,
-    [aux_sym_STR_interface] = 1,
-    [aux_sym_STR_return] = 1,
-    [aux_sym_STR_COMMA] = 1,
-    [aux_sym_STR_COLON_EQ] = 1,
-    [aux_sym_STR_for] = 1,
-    [aux_sym_STR_range] = 1,
-    [aux_sym_STR_if] = 1,
-    [aux_sym_STR_else] = 1,
-    [aux_sym_STR_DOT] = 1,
-    [aux_sym_STR_SLASH] = 1,
-    [aux_sym_STR_PLUS] = 1,
-    [aux_sym_STR_DASH] = 1,
-    [aux_sym_STR_PIPE_PIPE] = 1,
-    [aux_sym_STR_AMP_AMP] = 1,
-    [aux_sym_STR_EQ_EQ] = 1,
-    [aux_sym_STR_LT_EQ] = 1,
-    [aux_sym_STR_LT] = 1,
-    [aux_sym_STR_GT_EQ] = 1,
-    [aux_sym_STR_GT] = 1,
-    [aux_sym_STR_BANG] = 1,
+    [aux_sym_package] = 1,
+    [aux_sym_import] = 1,
+    [aux_sym_LPAREN] = 1,
+    [aux_sym_RPAREN] = 1,
+    [aux_sym_type] = 1,
+    [aux_sym_SEMI] = 1,
+    [aux_sym_var] = 1,
+    [aux_sym_EQ] = 1,
+    [aux_sym_func] = 1,
+    [aux_sym_LBRACE] = 1,
+    [aux_sym_RBRACE] = 1,
+    [aux_sym_STAR] = 1,
+    [aux_sym_map] = 1,
+    [aux_sym_LBRACK] = 1,
+    [aux_sym_RBRACK] = 1,
+    [aux_sym_struct] = 1,
+    [aux_sym_interface] = 1,
+    [aux_sym_return] = 1,
+    [aux_sym_COMMA] = 1,
+    [aux_sym_COLON_EQ] = 1,
+    [aux_sym_for] = 1,
+    [aux_sym_range] = 1,
+    [aux_sym_if] = 1,
+    [aux_sym_else] = 1,
+    [aux_sym_DOT] = 1,
+    [aux_sym_SLASH] = 1,
+    [aux_sym_PLUS] = 1,
+    [aux_sym_DASH] = 1,
+    [aux_sym_PIPE_PIPE] = 1,
+    [aux_sym_AMP_AMP] = 1,
+    [aux_sym_EQ_EQ] = 1,
+    [aux_sym_LT_EQ] = 1,
+    [aux_sym_LT] = 1,
+    [aux_sym_GT_EQ] = 1,
+    [aux_sym_GT] = 1,
+    [aux_sym_BANG] = 1,
+    [sym__line_break] = 1,
+    [sym__identifier] = 1,
 };
 
 static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@@ -284,7 +284,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(11);
             LEX_ERROR();
         case 11:
-            ACCEPT_TOKEN(aux_sym_STR_package);
+            ACCEPT_TOKEN(aux_sym_package);
         case 12:
             START_TOKEN();
             if (lookahead == 0)
@@ -334,7 +334,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(18);
             LEX_ERROR();
         case 18:
-            ACCEPT_TOKEN(aux_sym_STR_func);
+            ACCEPT_TOKEN(aux_sym_func);
         case 19:
             if (lookahead == 'm')
                 ADVANCE(20);
@@ -356,7 +356,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(24);
             LEX_ERROR();
         case 24:
-            ACCEPT_TOKEN(aux_sym_STR_import);
+            ACCEPT_TOKEN(aux_sym_import);
         case 25:
             if (lookahead == 'y')
                 ADVANCE(26);
@@ -370,7 +370,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(28);
             LEX_ERROR();
         case 28:
-            ACCEPT_TOKEN(aux_sym_STR_type);
+            ACCEPT_TOKEN(aux_sym_type);
         case 29:
             if (lookahead == 'a')
                 ADVANCE(30);
@@ -380,7 +380,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(31);
             LEX_ERROR();
         case 31:
-            ACCEPT_TOKEN(aux_sym_STR_var);
+            ACCEPT_TOKEN(aux_sym_var);
         case 32:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -479,7 +479,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(40);
             LEX_ERROR();
         case 41:
-            ACCEPT_TOKEN(aux_sym_STR_LPAREN);
+            ACCEPT_TOKEN(aux_sym_LPAREN);
         case 42:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -507,7 +507,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(44);
             LEX_ERROR();
         case 44:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACE);
+            ACCEPT_TOKEN(aux_sym_LBRACE);
         case 45:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -525,7 +525,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(33);
             LEX_ERROR();
         case 46:
-            ACCEPT_TOKEN(aux_sym_STR_RPAREN);
+            ACCEPT_TOKEN(aux_sym_RPAREN);
         case 47:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -556,11 +556,11 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(63);
             LEX_ERROR();
         case 48:
-            ACCEPT_TOKEN(aux_sym_STR_STAR);
+            ACCEPT_TOKEN(aux_sym_STAR);
         case 49:
-            ACCEPT_TOKEN(aux_sym_STR_COMMA);
+            ACCEPT_TOKEN(aux_sym_COMMA);
         case 50:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACK);
+            ACCEPT_TOKEN(aux_sym_LBRACK);
         case 51:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -647,7 +647,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_interface);
+            ACCEPT_TOKEN(aux_sym_interface);
         case 60:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -673,7 +673,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_map);
+            ACCEPT_TOKEN(aux_sym_map);
         case 63:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -731,7 +731,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_struct);
+            ACCEPT_TOKEN(aux_sym_struct);
         case 69:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -850,7 +850,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(76);
             LEX_ERROR();
         case 76:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACK);
+            ACCEPT_TOKEN(aux_sym_RBRACK);
         case 77:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -868,7 +868,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(78);
             LEX_ERROR();
         case 78:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACE);
+            ACCEPT_TOKEN(aux_sym_RBRACE);
         case 79:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -914,7 +914,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(82);
             LEX_ERROR();
         case 82:
-            ACCEPT_TOKEN(aux_sym_STR_SEMI);
+            ACCEPT_TOKEN(aux_sym_SEMI);
         case 83:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -953,7 +953,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(78);
             LEX_ERROR();
         case 84:
-            ACCEPT_TOKEN(aux_sym_STR_BANG);
+            ACCEPT_TOKEN(aux_sym_BANG);
         case 85:
             if (lookahead == '.')
                 ADVANCE(86);
@@ -973,7 +973,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(89);
             LEX_ERROR();
         case 89:
-            ACCEPT_TOKEN(aux_sym_STR_COLON_EQ);
+            ACCEPT_TOKEN(aux_sym_COLON_EQ);
         case 90:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -1000,7 +1000,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_for);
+            ACCEPT_TOKEN(aux_sym_for);
         case 93:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -1017,7 +1017,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_if);
+            ACCEPT_TOKEN(aux_sym_if);
         case 95:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -1074,7 +1074,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_return);
+            ACCEPT_TOKEN(aux_sym_return);
         case 101:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -1100,7 +1100,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_var);
+            ACCEPT_TOKEN(aux_sym_var);
         case 104:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1139,41 +1139,41 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(106);
             LEX_ERROR();
         case 106:
-            ACCEPT_TOKEN(aux_sym_STR_AMP_AMP);
+            ACCEPT_TOKEN(aux_sym_AMP_AMP);
         case 107:
-            ACCEPT_TOKEN(aux_sym_STR_PLUS);
+            ACCEPT_TOKEN(aux_sym_PLUS);
         case 108:
-            ACCEPT_TOKEN(aux_sym_STR_DASH);
+            ACCEPT_TOKEN(aux_sym_DASH);
         case 109:
-            ACCEPT_TOKEN(aux_sym_STR_DOT);
+            ACCEPT_TOKEN(aux_sym_DOT);
         case 110:
             if (lookahead == '/')
                 ADVANCE(4);
-            ACCEPT_TOKEN(aux_sym_STR_SLASH);
+            ACCEPT_TOKEN(aux_sym_SLASH);
         case 111:
             if (lookahead == '=')
                 ADVANCE(112);
-            ACCEPT_TOKEN(aux_sym_STR_LT);
+            ACCEPT_TOKEN(aux_sym_LT);
         case 112:
-            ACCEPT_TOKEN(aux_sym_STR_LT_EQ);
+            ACCEPT_TOKEN(aux_sym_LT_EQ);
         case 113:
             if (lookahead == '=')
                 ADVANCE(114);
             LEX_ERROR();
         case 114:
-            ACCEPT_TOKEN(aux_sym_STR_EQ_EQ);
+            ACCEPT_TOKEN(aux_sym_EQ_EQ);
         case 115:
             if (lookahead == '=')
                 ADVANCE(116);
-            ACCEPT_TOKEN(aux_sym_STR_GT);
+            ACCEPT_TOKEN(aux_sym_GT);
         case 116:
-            ACCEPT_TOKEN(aux_sym_STR_GT_EQ);
+            ACCEPT_TOKEN(aux_sym_GT_EQ);
         case 117:
             if (lookahead == '|')
                 ADVANCE(118);
             LEX_ERROR();
         case 118:
-            ACCEPT_TOKEN(aux_sym_STR_PIPE_PIPE);
+            ACCEPT_TOKEN(aux_sym_PIPE_PIPE);
         case 119:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1361,7 +1361,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_else);
+            ACCEPT_TOKEN(aux_sym_else);
         case 128:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1439,7 +1439,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(132);
             LEX_ERROR();
         case 132:
-            ACCEPT_TOKEN(aux_sym_STR_if);
+            ACCEPT_TOKEN(aux_sym_if);
         case 133:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1485,7 +1485,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(139);
             LEX_ERROR();
         case 139:
-            ACCEPT_TOKEN(aux_sym_STR_range);
+            ACCEPT_TOKEN(aux_sym_range);
         case 140:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1723,7 +1723,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(63);
             LEX_ERROR();
         case 146:
-            ACCEPT_TOKEN(aux_sym_STR_EQ);
+            ACCEPT_TOKEN(aux_sym_EQ);
         case 147:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1967,7 +1967,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
         case 154:
             if (lookahead == '=')
                 ADVANCE(114);
-            ACCEPT_TOKEN(aux_sym_STR_EQ);
+            ACCEPT_TOKEN(aux_sym_EQ);
         case 155:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -2008,7 +2008,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_func);
+            ACCEPT_TOKEN(aux_sym_func);
         case 159:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -2070,7 +2070,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_import);
+            ACCEPT_TOKEN(aux_sym_import);
         case 165:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -2136,7 +2136,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_package);
+            ACCEPT_TOKEN(aux_sym_package);
         case 172:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -2185,7 +2185,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_range);
+            ACCEPT_TOKEN(aux_sym_range);
         case 177:
             if (('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -2222,7 +2222,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(33);
-            ACCEPT_TOKEN(aux_sym_STR_type);
+            ACCEPT_TOKEN(aux_sym_type);
         case ts_lex_state_error:
             START_TOKEN();
             if (lookahead == 0)
@@ -2333,11 +2333,11 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [17] = 43,
     [18] = 45,
     [19] = 47,
-    [20] = 47,
-    [21] = 69,
+    [20] = 69,
+    [21] = 47,
     [22] = 43,
-    [23] = 43,
-    [24] = 32,
+    [23] = 32,
+    [24] = 43,
     [25] = 32,
     [26] = 70,
     [27] = 71,
@@ -2359,14 +2359,14 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [43] = 43,
     [44] = 70,
     [45] = 70,
-    [46] = 70,
+    [46] = 73,
     [47] = 73,
-    [48] = 73,
-    [49] = 74,
-    [50] = 75,
+    [48] = 74,
+    [49] = 75,
+    [50] = 43,
     [51] = 43,
-    [52] = 43,
-    [53] = 32,
+    [52] = 32,
+    [53] = 70,
     [54] = 47,
     [55] = 73,
     [56] = 77,
@@ -2426,18 +2426,18 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [110] = 79,
     [111] = 77,
     [112] = 73,
-    [113] = 73,
-    [114] = 79,
-    [115] = 70,
+    [113] = 79,
+    [114] = 70,
+    [115] = 73,
     [116] = 70,
     [117] = 77,
     [118] = 77,
-    [119] = 77,
-    [120] = 73,
-    [121] = 74,
-    [122] = 75,
+    [119] = 73,
+    [120] = 74,
+    [121] = 75,
+    [122] = 43,
     [123] = 43,
-    [124] = 43,
+    [124] = 77,
     [125] = 77,
     [126] = 79,
     [127] = 77,
@@ -2451,12 +2451,12 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [135] = 73,
     [136] = 75,
     [137] = 75,
-    [138] = 75,
-    [139] = 73,
-    [140] = 74,
-    [141] = 75,
+    [138] = 73,
+    [139] = 74,
+    [140] = 75,
+    [141] = 43,
     [142] = 43,
-    [143] = 43,
+    [143] = 75,
     [144] = 77,
     [145] = 79,
     [146] = 75,
@@ -2517,20 +2517,20 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [201] = 104,
     [202] = 119,
     [203] = 79,
-    [204] = 119,
-    [205] = 32,
-    [206] = 81,
-    [207] = 120,
-    [208] = 121,
-    [209] = 32,
+    [204] = 32,
+    [205] = 81,
+    [206] = 120,
+    [207] = 121,
+    [208] = 32,
+    [209] = 121,
     [210] = 121,
-    [211] = 121,
+    [211] = 119,
     [212] = 104,
     [213] = 104,
     [214] = 122,
     [215] = 122,
-    [216] = 122,
-    [217] = 121,
+    [216] = 121,
+    [217] = 122,
     [218] = 122,
     [219] = 123,
     [220] = 128,
@@ -2552,9 +2552,9 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [236] = 123,
     [237] = 129,
     [238] = 129,
-    [239] = 129,
-    [240] = 122,
-    [241] = 121,
+    [239] = 122,
+    [240] = 121,
+    [241] = 129,
     [242] = 129,
     [243] = 72,
     [244] = 128,
@@ -2600,8 +2600,8 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [284] = 122,
     [285] = 83,
     [286] = 104,
-    [287] = 141,
-    [288] = 128,
+    [287] = 128,
+    [288] = 141,
     [289] = 121,
     [290] = 32,
     [291] = 121,
@@ -2622,12 +2622,12 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [306] = 142,
     [307] = 142,
     [308] = 143,
-    [309] = 142,
-    [310] = 121,
+    [309] = 121,
+    [310] = 142,
     [311] = 142,
-    [312] = 144,
-    [313] = 81,
-    [314] = 128,
+    [312] = 81,
+    [313] = 128,
+    [314] = 144,
     [315] = 121,
     [316] = 121,
     [317] = 32,
@@ -2653,13 +2653,13 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [337] = 145,
     [338] = 147,
     [339] = 147,
-    [340] = 147,
-    [341] = 121,
-    [342] = 73,
-    [343] = 74,
-    [344] = 75,
+    [340] = 121,
+    [341] = 73,
+    [342] = 74,
+    [343] = 75,
+    [344] = 43,
     [345] = 43,
-    [346] = 43,
+    [346] = 147,
     [347] = 77,
     [348] = 79,
     [349] = 147,
@@ -2709,12 +2709,12 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [393] = 73,
     [394] = 81,
     [395] = 81,
-    [396] = 81,
-    [397] = 73,
-    [398] = 74,
-    [399] = 75,
+    [396] = 73,
+    [397] = 74,
+    [398] = 75,
+    [399] = 43,
     [400] = 43,
-    [401] = 43,
+    [401] = 81,
     [402] = 77,
     [403] = 79,
     [404] = 81,
@@ -2732,12 +2732,12 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [416] = 81,
     [417] = 149,
     [418] = 14,
-    [419] = 14,
-    [420] = 152,
+    [419] = 152,
+    [420] = 14,
     [421] = 152,
     [422] = 72,
-    [423] = 152,
-    [424] = 14,
+    [423] = 14,
+    [424] = 152,
     [425] = 14,
     [426] = 72,
     [427] = 12,
@@ -2752,9 +2752,9 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     [0] = {
         [sym_program] = ACTIONS(SHIFT(1)),
         [sym_package_directive] = ACTIONS(SHIFT(2)),
+        [aux_sym_package] = ACTIONS(SHIFT(3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_package] = ACTIONS(SHIFT(3)),
     },
     [1] = {
         [ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
@@ -2767,15 +2767,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_declaration] = ACTIONS(SHIFT(8)),
         [sym_var_declaration] = ACTIONS(SHIFT(8)),
         [sym_func_declaration] = ACTIONS(SHIFT(8)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(SHIFT(9)),
         [aux_sym_program_repeat2] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_import] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_type] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_func] = ACTIONS(SHIFT(14)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
+        [aux_sym_import] = ACTIONS(SHIFT(11)),
+        [aux_sym_type] = ACTIONS(SHIFT(12)),
+        [aux_sym_var] = ACTIONS(SHIFT(13)),
+        [aux_sym_func] = ACTIONS(SHIFT(14)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [3] = {
         [sym_package_name] = ACTIONS(SHIFT(4)),
@@ -2789,15 +2789,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_declaration] = ACTIONS(REDUCE(sym_package_directive, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_package_directive, 2)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_package_directive, 2)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_package_directive, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_package_directive, 2)),
         [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_package_directive, 2)),
-        [aux_sym_STR_import] = ACTIONS(REDUCE(sym_package_directive, 2)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_package_directive, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_package_directive, 2)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_package_directive, 2)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_package_directive, 2)),
+        [aux_sym_import] = ACTIONS(REDUCE(sym_package_directive, 2)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_package_directive, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_package_directive, 2)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_package_directive, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [5] = {
         [sym_imports_block] = ACTIONS(REDUCE(sym_package_name, 1)),
@@ -2805,15 +2805,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_declaration] = ACTIONS(REDUCE(sym_package_name, 1)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_package_name, 1)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_package_name, 1)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_package_name, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_package_name, 1)),
         [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_package_name, 1)),
-        [aux_sym_STR_import] = ACTIONS(REDUCE(sym_package_name, 1)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_package_name, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_package_name, 1)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_package_name, 1)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_package_name, 1)),
+        [aux_sym_import] = ACTIONS(REDUCE(sym_package_name, 1)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_package_name, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_package_name, 1)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_package_name, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [6] = {
         [sym_imports_block] = ACTIONS(SHIFT(6)),
@@ -2821,54 +2821,54 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_declaration] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
         [sym_var_declaration] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
         [sym_func_declaration] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(SHIFT(429)),
         [aux_sym_program_repeat2] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_import] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_import] = ACTIONS(SHIFT(11)),
+        [aux_sym_type] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_func] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [7] = {
         [sym__declaration] = ACTIONS(SHIFT(7)),
         [sym_type_declaration] = ACTIONS(SHIFT(8)),
         [sym_var_declaration] = ACTIONS(SHIFT(8)),
         [sym_func_declaration] = ACTIONS(SHIFT(8)),
+        [aux_sym_program_repeat2] = ACTIONS(SHIFT(428)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat2, 1)),
+        [aux_sym_type] = ACTIONS(SHIFT(12)),
+        [aux_sym_var] = ACTIONS(SHIFT(13)),
+        [aux_sym_func] = ACTIONS(SHIFT(14)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(SHIFT(428)),
-        [aux_sym_STR_type] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_func] = ACTIONS(SHIFT(14)),
     },
     [8] = {
         [sym__declaration] = ACTIONS(REDUCE(sym__declaration, 1)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym__declaration, 1)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym__declaration, 1)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym__declaration, 1)),
+        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym__declaration, 1)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym__declaration, 1)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym__declaration, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__declaration, 1)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym__declaration, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym__declaration, 1)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym__declaration, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__declaration, 1)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym__declaration, 1)),
     },
     [9] = {
         [sym__declaration] = ACTIONS(SHIFT(7)),
         [sym_type_declaration] = ACTIONS(SHIFT(8)),
         [sym_var_declaration] = ACTIONS(SHIFT(8)),
         [sym_func_declaration] = ACTIONS(SHIFT(8)),
+        [aux_sym_program_repeat2] = ACTIONS(SHIFT(427)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 2)),
+        [aux_sym_type] = ACTIONS(SHIFT(12)),
+        [aux_sym_var] = ACTIONS(SHIFT(13)),
+        [aux_sym_func] = ACTIONS(SHIFT(14)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(SHIFT(427)),
-        [aux_sym_STR_type] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_func] = ACTIONS(SHIFT(14)),
     },
     [10] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 2)),
@@ -2877,10 +2877,10 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [11] = {
         [sym_package_import] = ACTIONS(SHIFT(418)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(419)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(419)),
+        [sym_string] = ACTIONS(SHIFT(420)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(420)),
     },
     [12] = {
         [sym_type_name] = ACTIONS(SHIFT(392)),
@@ -2902,28 +2902,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [15] = {
         [sym__func_signature] = ACTIONS(SHIFT(17)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(18)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(18)),
     },
     [16] = {
         [sym__func_signature] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
     },
     [17] = {
         [sym_block_statement] = ACTIONS(SHIFT(196)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(197)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(197)),
     },
     [18] = {
         [sym_var_name] = ACTIONS(SHIFT(19)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(20)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(20)),
+        [sym__identifier] = ACTIONS(SHIFT(21)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(21)),
     },
     [19] = {
         [sym__type_expression] = ACTIONS(SHIFT(44)),
@@ -2933,18 +2933,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
+        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(46)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(52)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(53)),
     },
     [20] = {
+        [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
+        [sym_type_name] = ACTIONS(SHIFT(22)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(23)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(24)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [21] = {
         [sym__type_expression] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_pointer_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_map_type] = ACTIONS(REDUCE(sym_var_name, 1)),
@@ -2952,45 +2961,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_interface_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_type_name] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_short_var_declaration_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_map] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_interface] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_short_var_declaration_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_map] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_interface] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
-    },
-    [21] = {
-        [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
-        [sym_type_name] = ACTIONS(SHIFT(22)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(23)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
     },
     [22] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 3)),
     },
     [23] = {
-        [sym_block_statement] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_type_name, 1)),
-    },
-    [24] = {
         [sym_var_name] = ACTIONS(SHIFT(25)),
         [sym_type_name] = ACTIONS(SHIFT(26)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
+    [24] = {
+        [sym_block_statement] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
     [25] = {
         [sym_type_name] = ACTIONS(SHIFT(35)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
@@ -2998,31 +2998,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [26] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(28)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(29)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(29)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [27] = {
         [sym_type_name] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym__func_signature_repeat3] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
     },
     [28] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(34)),
     },
     [29] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 5)),
     },
     [30] = {
         [sym_type_name] = ACTIONS(SHIFT(31)),
@@ -3031,48 +3031,48 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [31] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(33)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat3, 2)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(33)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat3, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [32] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
     },
     [33] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat3, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat3, 3)),
     },
     [34] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 6)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 6)),
     },
     [35] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(37)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(34)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(34)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [36] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
     },
     [37] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(43)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(43)),
     },
     [38] = {
         [sym_var_name] = ACTIONS(SHIFT(39)),
@@ -3093,45 +3093,38 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [41] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(42)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat2, 3)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat2, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [42] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat2, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat2, 4)),
     },
     [43] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 7)),
     },
     [44] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(189)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(190)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(80)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(80)),
     },
     [45] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym__type_expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__type_expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym__type_expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__type_expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__type_expression, 1)),
     },
     [46] = {
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
-    },
-    [47] = {
         [sym__type_expression] = ACTIONS(SHIFT(170)),
         [sym_pointer_type] = ACTIONS(SHIFT(45)),
         [sym_map_type] = ACTIONS(SHIFT(45)),
@@ -3139,16 +3132,16 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
     },
-    [48] = {
+    [47] = {
         [sym__type_expression] = ACTIONS(SHIFT(169)),
         [sym_pointer_type] = ACTIONS(SHIFT(45)),
         [sym_map_type] = ACTIONS(SHIFT(45)),
@@ -3156,39 +3149,46 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [48] = {
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(165)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
     },
     [49] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(163)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(165)),
     },
     [50] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(111)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(163)),
     },
     [51] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(56)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
     },
     [52] = {
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-    },
-    [53] = {
         [sym_var_name] = ACTIONS(SHIFT(54)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(20)),
+        [sym__identifier] = ACTIONS(SHIFT(21)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [53] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [54] = {
@@ -3199,16 +3199,16 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
         [sym_interface_type] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
         [sym_type_name] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
+        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(55)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
+        [aux_sym_map] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
+        [aux_sym_struct] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
+        [aux_sym_interface] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(52)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
-        [aux_sym_STR_map] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
-        [aux_sym_STR_interface] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(53)),
     },
     [55] = {
         [sym__type_expression] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
@@ -3218,62 +3218,62 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
         [sym_interface_type] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
         [sym_type_name] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
+        [aux_sym_map] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
+        [aux_sym_struct] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
+        [aux_sym_interface] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
-        [aux_sym_STR_map] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
-        [aux_sym_STR_interface] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
     },
     [56] = {
         [sym_var_name] = ACTIONS(SHIFT(57)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(58)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(59)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(16)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(59)),
     },
     [57] = {
         [sym__func_signature] = ACTIONS(SHIFT(61)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(62)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(62)),
     },
     [58] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(60)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(60)),
     },
     [59] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_interface_type, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_interface_type, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_interface_type, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_interface_type, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_interface_type, 3)),
     },
     [60] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_interface_type, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_interface_type, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_interface_type, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_interface_type, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_interface_type, 4)),
     },
     [61] = {
         [sym_var_name] = ACTIONS(SHIFT(57)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(110)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_interface_type_repeat1, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(16)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(110)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_interface_type_repeat1, 2)),
     },
     [62] = {
         [sym_var_name] = ACTIONS(SHIFT(63)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(64)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(20)),
+        [sym__identifier] = ACTIONS(SHIFT(21)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(64)),
     },
     [63] = {
         [sym__type_expression] = ACTIONS(SHIFT(75)),
@@ -3283,34 +3283,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(53)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(52)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [64] = {
         [sym_var_name] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
         [sym_type_name] = ACTIONS(SHIFT(65)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(66)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 2)),
     },
     [65] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 3)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 3)),
     },
     [66] = {
         [sym_var_name] = ACTIONS(SHIFT(67)),
@@ -3326,59 +3326,59 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [68] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(69)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(70)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(69)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(70)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [69] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(71)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(71)),
     },
     [70] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 5)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 5)),
     },
     [71] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 6)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 6)),
     },
     [72] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(73)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(71)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [73] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(74)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(74)),
     },
     [74] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 7)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 7)),
     },
     [75] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(103)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(104)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(80)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(103)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(104)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(80)),
     },
     [76] = {
         [sym__type_expression] = ACTIONS(SHIFT(77)),
@@ -3388,41 +3388,41 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
     },
     [77] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(78)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(79)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(80)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(80)),
     },
     [78] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(96)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(96)),
     },
     [79] = {
         [sym_var_name] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
         [sym_type_name] = ACTIONS(SHIFT(71)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(87)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(87)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
     },
     [80] = {
         [sym_var_name] = ACTIONS(SHIFT(81)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(20)),
+        [sym__identifier] = ACTIONS(SHIFT(21)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [81] = {
@@ -3433,23 +3433,23 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(83)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(53)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(52)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [82] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(86)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 3)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(80)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(86)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(80)),
     },
     [83] = {
         [sym__type_expression] = ACTIONS(SHIFT(84)),
@@ -3459,31 +3459,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
     },
     [84] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(85)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 4)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(80)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(85)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(80)),
     },
     [85] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 5)),
     },
     [86] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym__func_signature_repeat1, 4)),
     },
     [87] = {
         [sym_var_name] = ACTIONS(SHIFT(88)),
@@ -3499,62 +3499,62 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [89] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(90)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(91)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [90] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(92)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(92)),
     },
     [91] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 8)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 8)),
     },
     [92] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 9)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 9)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 9)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 9)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 9)),
     },
     [93] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(94)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(92)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [94] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(95)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(95)),
     },
     [95] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 10)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 10)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 10)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 10)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 10)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 10)),
     },
     [96] = {
         [sym_var_name] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
         [sym_type_name] = ACTIONS(SHIFT(74)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(97)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(97)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
     },
     [97] = {
         [sym_var_name] = ACTIONS(SHIFT(98)),
@@ -3570,46 +3570,46 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [99] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(94)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(92)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [100] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(101)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(95)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(95)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [101] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(102)),
     },
     [102] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__func_signature, 11)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 11)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 11)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__func_signature, 11)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE(sym__func_signature, 11)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__func_signature, 11)),
     },
     [103] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(79)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(79)),
     },
     [104] = {
         [sym_var_name] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
         [sym_type_name] = ACTIONS(SHIFT(70)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(105)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(105)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
     },
     [105] = {
         [sym_var_name] = ACTIONS(SHIFT(106)),
@@ -3625,36 +3625,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [107] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(108)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(74)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(108)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [108] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(91)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(91)),
     },
     [109] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(90)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(91)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [110] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_interface_type_repeat1, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_interface_type_repeat1, 3)),
     },
     [111] = {
         [sym_var_name] = ACTIONS(SHIFT(112)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(SHIFT(113)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(114)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(113)),
+        [sym__identifier] = ACTIONS(SHIFT(115)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(115)),
     },
     [112] = {
         [sym__type_expression] = ACTIONS(SHIFT(117)),
@@ -3664,16 +3664,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(118)),
         [sym_interface_type] = ACTIONS(SHIFT(118)),
         [sym_type_name] = ACTIONS(SHIFT(118)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(119)),
+        [aux_sym_map] = ACTIONS(SHIFT(120)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(121)),
+        [aux_sym_struct] = ACTIONS(SHIFT(122)),
+        [aux_sym_interface] = ACTIONS(SHIFT(123)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(119)),
+        [sym__identifier] = ACTIONS(SHIFT(124)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(120)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(124)),
     },
     [113] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(116)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [114] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_struct_type, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_struct_type, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_struct_type, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [115] = {
         [sym__type_expression] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_pointer_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_map_type] = ACTIONS(REDUCE(sym_var_name, 1)),
@@ -3681,59 +3693,39 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_interface_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_type_name] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_map] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_interface] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_map] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_interface] = ACTIONS(REDUCE(sym_var_name, 1)),
-    },
-    [114] = {
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(116)),
-    },
-    [115] = {
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_struct_type, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_struct_type, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_struct_type, 3)),
     },
     [116] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_struct_type, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_struct_type, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_struct_type, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_struct_type, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_struct_type, 4)),
     },
     [117] = {
         [sym_var_name] = ACTIONS(SHIFT(112)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(113)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_struct_type_repeat1] = ACTIONS(SHIFT(162)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_type_repeat1, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_type_repeat1, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(115)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [118] = {
         [sym_var_name] = ACTIONS(REDUCE(sym__type_expression, 1)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym__type_expression, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym__type_expression, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__type_expression, 1)),
     },
     [119] = {
-        [sym_var_name] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_type_name, 1)),
-    },
-    [120] = {
         [sym__type_expression] = ACTIONS(SHIFT(161)),
         [sym_pointer_type] = ACTIONS(SHIFT(118)),
         [sym_map_type] = ACTIONS(SHIFT(118)),
@@ -3741,92 +3733,100 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(118)),
         [sym_interface_type] = ACTIONS(SHIFT(118)),
         [sym_type_name] = ACTIONS(SHIFT(118)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(119)),
+        [aux_sym_map] = ACTIONS(SHIFT(120)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(121)),
+        [aux_sym_struct] = ACTIONS(SHIFT(122)),
+        [aux_sym_interface] = ACTIONS(SHIFT(123)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(124)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [120] = {
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(135)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(119)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(120)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(124)),
     },
     [121] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(133)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(135)),
     },
     [122] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(129)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(133)),
     },
     [123] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(125)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(129)),
     },
     [124] = {
+        [sym_var_name] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(125)),
     },
     [125] = {
         [sym_var_name] = ACTIONS(SHIFT(57)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(126)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(127)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(16)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(126)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(127)),
     },
     [126] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(128)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(128)),
     },
     [127] = {
         [sym_var_name] = ACTIONS(REDUCE(sym_interface_type, 3)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_interface_type, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_interface_type, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_interface_type, 3)),
     },
     [128] = {
         [sym_var_name] = ACTIONS(REDUCE(sym_interface_type, 4)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_interface_type, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_interface_type, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_interface_type, 4)),
     },
     [129] = {
         [sym_var_name] = ACTIONS(SHIFT(112)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(113)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_struct_type_repeat1] = ACTIONS(SHIFT(130)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(131)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(131)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(115)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [130] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(132)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(132)),
     },
     [131] = {
         [sym_var_name] = ACTIONS(REDUCE(sym_struct_type, 3)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_struct_type, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_struct_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_struct_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_struct_type, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_struct_type, 3)),
     },
     [132] = {
         [sym_var_name] = ACTIONS(REDUCE(sym_struct_type, 4)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_struct_type, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_struct_type, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_struct_type, 4)),
     },
     [133] = {
         [sym__type_expression] = ACTIONS(SHIFT(134)),
@@ -3836,22 +3836,22 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(118)),
         [sym_interface_type] = ACTIONS(SHIFT(118)),
         [sym_type_name] = ACTIONS(SHIFT(118)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(119)),
+        [aux_sym_map] = ACTIONS(SHIFT(120)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(121)),
+        [aux_sym_struct] = ACTIONS(SHIFT(122)),
+        [aux_sym_interface] = ACTIONS(SHIFT(123)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(119)),
+        [sym__identifier] = ACTIONS(SHIFT(124)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(120)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(124)),
     },
     [134] = {
         [sym_var_name] = ACTIONS(REDUCE(sym_slice_type, 3)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_slice_type, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_slice_type, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_slice_type, 3)),
     },
     [135] = {
         [sym__type_expression] = ACTIONS(SHIFT(136)),
@@ -3861,31 +3861,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [136] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(159)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(159)),
     },
     [137] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__type_expression, 1)),
     },
     [138] = {
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_type_name, 1)),
-    },
-    [139] = {
         [sym__type_expression] = ACTIONS(SHIFT(158)),
         [sym_pointer_type] = ACTIONS(SHIFT(137)),
         [sym_map_type] = ACTIONS(SHIFT(137)),
@@ -3893,80 +3888,85 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [139] = {
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(154)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [140] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(152)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(154)),
     },
     [141] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(148)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(152)),
     },
     [142] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(144)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(148)),
     },
     [143] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(144)),
     },
     [144] = {
         [sym_var_name] = ACTIONS(SHIFT(57)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(145)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(146)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(16)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(145)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(146)),
     },
     [145] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(147)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(147)),
     },
     [146] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_interface_type, 3)),
     },
     [147] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_interface_type, 4)),
     },
     [148] = {
         [sym_var_name] = ACTIONS(SHIFT(112)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(113)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_struct_type_repeat1] = ACTIONS(SHIFT(149)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(150)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(150)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(115)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [149] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(151)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(151)),
     },
     [150] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_struct_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_struct_type, 3)),
     },
     [151] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_struct_type, 4)),
     },
     [152] = {
         [sym__type_expression] = ACTIONS(SHIFT(153)),
@@ -3976,19 +3976,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [153] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_slice_type, 3)),
     },
     [154] = {
         [sym__type_expression] = ACTIONS(SHIFT(155)),
@@ -3998,19 +3998,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [155] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(156)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(156)),
     },
     [156] = {
         [sym__type_expression] = ACTIONS(SHIFT(157)),
@@ -4020,24 +4020,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [157] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_map_type, 5)),
     },
     [158] = {
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_pointer_type, 2)),
     },
     [159] = {
         [sym__type_expression] = ACTIONS(SHIFT(160)),
@@ -4047,35 +4047,35 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(118)),
         [sym_interface_type] = ACTIONS(SHIFT(118)),
         [sym_type_name] = ACTIONS(SHIFT(118)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(119)),
+        [aux_sym_map] = ACTIONS(SHIFT(120)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(121)),
+        [aux_sym_struct] = ACTIONS(SHIFT(122)),
+        [aux_sym_interface] = ACTIONS(SHIFT(123)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(119)),
+        [sym__identifier] = ACTIONS(SHIFT(124)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(120)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(124)),
     },
     [160] = {
         [sym_var_name] = ACTIONS(REDUCE(sym_map_type, 5)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_map_type, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_map_type, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_map_type, 5)),
     },
     [161] = {
         [sym_var_name] = ACTIONS(REDUCE(sym_pointer_type, 2)),
+        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_pointer_type, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_struct_type_repeat1] = ACTIONS(REDUCE(sym_pointer_type, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_pointer_type, 2)),
     },
     [162] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_type_repeat1, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_struct_type_repeat1, 3)),
     },
     [163] = {
         [sym__type_expression] = ACTIONS(SHIFT(164)),
@@ -4085,21 +4085,21 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
     },
     [164] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_slice_type, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_slice_type, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_slice_type, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_slice_type, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_slice_type, 3)),
     },
     [165] = {
         [sym__type_expression] = ACTIONS(SHIFT(166)),
@@ -4109,19 +4109,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [166] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(167)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(167)),
     },
     [167] = {
         [sym__type_expression] = ACTIONS(SHIFT(168)),
@@ -4131,49 +4131,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(45)),
         [sym_interface_type] = ACTIONS(SHIFT(45)),
         [sym_type_name] = ACTIONS(SHIFT(45)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(47)),
+        [aux_sym_map] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(49)),
+        [aux_sym_struct] = ACTIONS(SHIFT(50)),
+        [aux_sym_interface] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(46)),
+        [sym__identifier] = ACTIONS(SHIFT(53)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(50)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(51)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(52)),
     },
     [168] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_map_type, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_map_type, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_map_type, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_map_type, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_map_type, 5)),
     },
     [169] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_pointer_type, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_pointer_type, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(REDUCE(sym_pointer_type, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_pointer_type, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_pointer_type, 2)),
     },
     [170] = {
+        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(171)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(172)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(80)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat1] = ACTIONS(SHIFT(171)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(172)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(80)),
     },
     [171] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(182)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(182)),
     },
     [172] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
         [sym_type_name] = ACTIONS(SHIFT(34)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(173)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(23)),
+        [sym__identifier] = ACTIONS(SHIFT(24)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(173)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 5)),
     },
     [173] = {
         [sym_var_name] = ACTIONS(SHIFT(174)),
@@ -4189,55 +4189,55 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [175] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(176)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(177)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(176)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(177)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [176] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(178)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(178)),
     },
     [177] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 8)),
     },
     [178] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 9)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 9)),
     },
     [179] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(180)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(178)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(180)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(178)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [180] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(181)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(181)),
     },
     [181] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 10)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 10)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 10)),
     },
     [182] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
         [sym_type_name] = ACTIONS(SHIFT(43)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(183)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(23)),
+        [sym__identifier] = ACTIONS(SHIFT(24)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(183)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 6)),
     },
     [183] = {
         [sym_var_name] = ACTIONS(SHIFT(184)),
@@ -4253,43 +4253,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [185] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(180)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(178)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(180)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(178)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [186] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(187)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(181)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(181)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [187] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(188)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(188)),
     },
     [188] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__func_signature, 11)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 11)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__func_signature, 11)),
     },
     [189] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(172)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(172)),
     },
     [190] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
         [sym_type_name] = ACTIONS(SHIFT(29)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(191)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(23)),
+        [sym__identifier] = ACTIONS(SHIFT(24)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym__func_signature, 4)),
     },
     [191] = {
         [sym_var_name] = ACTIONS(SHIFT(192)),
@@ -4305,28 +4305,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [193] = {
+        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(194)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(43)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat3] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(43)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(30)),
     },
     [194] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(177)),
     },
     [195] = {
+        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(176)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(177)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(38)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym__func_signature_repeat2] = ACTIONS(SHIFT(176)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(177)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(38)),
     },
     [196] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(382)),
         [sym__line_break] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(382)),
     },
     [197] = {
         [sym_var_declaration] = ACTIONS(SHIFT(198)),
@@ -4342,20 +4342,20 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(202)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(203)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(203)),
+        [aux_sym_var] = ACTIONS(SHIFT(204)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(205)),
+        [aux_sym_return] = ACTIONS(SHIFT(206)),
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(207)),
+        [aux_sym_for] = ACTIONS(SHIFT(208)),
+        [aux_sym_if] = ACTIONS(SHIFT(209)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
-        [sym__identifier] = ACTIONS(SHIFT(204)),
+        [sym__identifier] = ACTIONS(SHIFT(211)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(208)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(209)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(210)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [198] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -4371,19 +4371,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_bool_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_var_name] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym__identifier] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_number] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
     },
     [199] = {
         [sym_var_declaration] = ACTIONS(SHIFT(198)),
@@ -4399,302 +4399,302 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(202)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(381)),
+        [aux_sym_var] = ACTIONS(SHIFT(204)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_block_statement_repeat1, 1)),
+        [aux_sym_return] = ACTIONS(SHIFT(206)),
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(207)),
+        [aux_sym_for] = ACTIONS(SHIFT(208)),
+        [aux_sym_if] = ACTIONS(SHIFT(209)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
-        [sym__identifier] = ACTIONS(SHIFT(204)),
+        [sym__identifier] = ACTIONS(SHIFT(211)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(381)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_block_statement_repeat1, 1)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(208)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(209)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(210)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [200] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(380)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT(380)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(380)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [201] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [202] = {
+        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(369)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(370)),
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(371)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(369)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(370)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(371)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [203] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(368)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(368)),
     },
     [204] = {
-        [sym__line_break] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_short_var_declaration_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
-    },
-    [205] = {
         [sym_var_name] = ACTIONS(SHIFT(336)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(337)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [206] = {
+    [205] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym__line_break] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_block_statement, 2)),
     },
-    [207] = {
+    [206] = {
         [sym__expression] = ACTIONS(SHIFT(306)),
         [sym_call_expression] = ACTIONS(SHIFT(307)),
         [sym_selector_expression] = ACTIONS(SHIFT(307)),
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(308)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT(308)),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(308)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
     },
-    [208] = {
+    [207] = {
         [sym__expression] = ACTIONS(SHIFT(286)),
         [sym_call_expression] = ACTIONS(SHIFT(201)),
         [sym_selector_expression] = ACTIONS(SHIFT(201)),
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
-    [209] = {
+    [208] = {
         [sym_var_name] = ACTIONS(SHIFT(273)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(274)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
-    [210] = {
+    [209] = {
         [sym__expression] = ACTIONS(SHIFT(214)),
         [sym_call_expression] = ACTIONS(SHIFT(215)),
         [sym_selector_expression] = ACTIONS(SHIFT(215)),
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
-    [211] = {
+    [210] = {
         [sym__expression] = ACTIONS(SHIFT(212)),
         [sym_call_expression] = ACTIONS(SHIFT(201)),
         [sym_selector_expression] = ACTIONS(SHIFT(201)),
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
-    [212] = {
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-    },
-    [213] = {
+    [211] = {
+        [aux_sym_short_var_declaration_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [212] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [213] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
     },
     [214] = {
         [sym_block_statement] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(220)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(221)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(222)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(223)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(222)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(224)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(224)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(225)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(226)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT] = ACTIONS(SHIFT(227)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(221)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(227)),
     },
     [215] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [216] = {
-        [sym_block_statement] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
-    },
-    [217] = {
         [sym__expression] = ACTIONS(SHIFT(218)),
         [sym_call_expression] = ACTIONS(SHIFT(215)),
         [sym_selector_expression] = ACTIONS(SHIFT(215)),
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
+    },
+    [217] = {
+        [sym_block_statement] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [218] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [219] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_if_statement, 3)),
@@ -4710,20 +4710,20 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 3)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_if_statement, 3)),
         [sym_var_name] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 3)),
+        [aux_sym_else] = ACTIONS(SHIFT(267)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_if_statement, 3)),
         [sym__identifier] = ACTIONS(REDUCE(sym_if_statement, 3)),
         [sym_number] = ACTIONS(REDUCE(sym_if_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 3)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_if_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(SHIFT(267)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 3)),
     },
     [220] = {
         [sym__expression] = ACTIONS(SHIFT(237)),
@@ -4732,13 +4732,13 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(239)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(240)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [221] = {
         [sym_var_declaration] = ACTIONS(SHIFT(198)),
@@ -4754,20 +4754,20 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(202)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(234)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(234)),
+        [aux_sym_var] = ACTIONS(SHIFT(204)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(235)),
+        [aux_sym_return] = ACTIONS(SHIFT(206)),
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(207)),
+        [aux_sym_for] = ACTIONS(SHIFT(208)),
+        [aux_sym_if] = ACTIONS(SHIFT(209)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
-        [sym__identifier] = ACTIONS(SHIFT(204)),
+        [sym__identifier] = ACTIONS(SHIFT(211)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(234)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(235)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(208)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(209)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(210)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [222] = {
         [sym__expression] = ACTIONS(SHIFT(233)),
@@ -4776,17 +4776,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
     [223] = {
         [sym_var_name] = ACTIONS(SHIFT(232)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [224] = {
@@ -4796,12 +4796,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
     [225] = {
         [sym__expression] = ACTIONS(SHIFT(230)),
@@ -4810,12 +4810,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
     [226] = {
         [sym__expression] = ACTIONS(SHIFT(229)),
@@ -4824,12 +4824,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
     [227] = {
         [sym__expression] = ACTIONS(SHIFT(228)),
@@ -4838,131 +4838,131 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
     [228] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
     },
     [229] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT] = ACTIONS(SHIFT(227)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(227)),
     },
     [230] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(222)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(222)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(226)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT] = ACTIONS(SHIFT(227)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(227)),
     },
     [231] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(222)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(222)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(226)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT] = ACTIONS(SHIFT(227)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(227)),
     },
     [232] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
     },
     [233] = {
         [sym_block_statement] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT] = ACTIONS(SHIFT(227)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(227)),
     },
     [234] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(236)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(236)),
     },
     [235] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_block_statement, 2)),
@@ -4978,20 +4978,20 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_var_name] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym__identifier] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_number] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_block_statement, 2)),
     },
     [236] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_block_statement, 3)),
@@ -5007,138 +5007,138 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_var_name] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym__identifier] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_number] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_block_statement, 3)),
     },
     [237] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(243)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(244)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(245)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(246)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(247)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(248)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(246)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(250)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(243)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(244)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(245)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(247)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(248)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(250)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(251)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [238] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [239] = {
+        [sym_block_statement] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
     },
     [240] = {
-        [sym_block_statement] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-    },
-    [241] = {
         [sym__expression] = ACTIONS(SHIFT(242)),
         [sym_call_expression] = ACTIONS(SHIFT(238)),
         [sym_selector_expression] = ACTIONS(SHIFT(238)),
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
+    },
+    [241] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [242] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [243] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(266)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(266)),
     },
     [244] = {
         [sym__expression] = ACTIONS(SHIFT(261)),
@@ -5147,32 +5147,32 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(262)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(262)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [245] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
     },
     [246] = {
         [sym__expression] = ACTIONS(SHIFT(260)),
@@ -5181,12 +5181,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [247] = {
         [sym__expression] = ACTIONS(SHIFT(258)),
@@ -5195,17 +5195,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [248] = {
         [sym_var_name] = ACTIONS(SHIFT(257)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [249] = {
@@ -5215,12 +5215,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [250] = {
         [sym__expression] = ACTIONS(SHIFT(255)),
@@ -5229,12 +5229,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [251] = {
         [sym__expression] = ACTIONS(SHIFT(254)),
@@ -5243,12 +5243,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [252] = {
         [sym__expression] = ACTIONS(SHIFT(253)),
@@ -5257,269 +5257,269 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(238)),
         [sym_bool_op] = ACTIONS(SHIFT(238)),
         [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
         [sym_number] = ACTIONS(SHIFT(238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [253] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
     },
     [254] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [255] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(246)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(246)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(251)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [256] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(246)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(246)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(251)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [257] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
     },
     [258] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(259)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(244)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 2)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(246)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(247)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(248)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(246)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(250)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(244)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(247)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(248)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(250)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(251)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [259] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 3)),
     },
     [260] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [261] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(263)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(244)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(264)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(246)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(247)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(248)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(246)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(250)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(263)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(244)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(264)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(247)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(248)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(250)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(251)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [262] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
     },
     [263] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(265)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(265)),
     },
     [264] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
     },
     [265] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
     },
     [266] = {
         [sym_block_statement] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
     },
     [267] = {
         [sym_block_statement] = ACTIONS(SHIFT(268)),
         [sym_if_statement] = ACTIONS(SHIFT(268)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(269)),
+        [aux_sym_if] = ACTIONS(SHIFT(209)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(269)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(210)),
     },
     [268] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -5535,19 +5535,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_var_name] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__identifier] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_number] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
     },
     [269] = {
         [sym_var_declaration] = ACTIONS(SHIFT(198)),
@@ -5563,25 +5563,25 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(202)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(270)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(270)),
+        [aux_sym_var] = ACTIONS(SHIFT(204)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(271)),
+        [aux_sym_return] = ACTIONS(SHIFT(206)),
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(207)),
+        [aux_sym_for] = ACTIONS(SHIFT(208)),
+        [aux_sym_if] = ACTIONS(SHIFT(209)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
-        [sym__identifier] = ACTIONS(SHIFT(204)),
+        [sym__identifier] = ACTIONS(SHIFT(211)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(SHIFT(270)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(208)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(209)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(210)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [270] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(272)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(272)),
     },
     [271] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_block_statement, 2)),
@@ -5597,19 +5597,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_var_name] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_block_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym__identifier] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_number] = ACTIONS(REDUCE(sym_block_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_block_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_block_statement, 2)),
     },
     [272] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_block_statement, 3)),
@@ -5625,31 +5625,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_var_name] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_block_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym__identifier] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_number] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_block_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_block_statement, 3)),
     },
     [273] = {
+        [aux_sym_COMMA] = ACTIONS(SHIFT(275)),
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(276)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(276)),
     },
     [274] = {
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
     },
     [275] = {
         [sym_var_name] = ACTIONS(SHIFT(280)),
@@ -5658,9 +5658,9 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [276] = {
+        [aux_sym_range] = ACTIONS(SHIFT(277)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_range] = ACTIONS(SHIFT(277)),
     },
     [277] = {
         [sym__expression] = ACTIONS(SHIFT(278)),
@@ -5669,31 +5669,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
     [278] = {
         [sym_block_statement] = ACTIONS(SHIFT(279)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(220)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(269)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(222)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(223)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(222)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(224)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(224)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(225)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(226)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT] = ACTIONS(SHIFT(227)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(269)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(227)),
     },
     [279] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_range_statement, 6)),
@@ -5709,34 +5709,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_range_statement, 6)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_range_statement, 6)),
         [sym_var_name] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_range_statement, 6)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_range_statement, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_range_statement, 6)),
         [sym__identifier] = ACTIONS(REDUCE(sym_range_statement, 6)),
         [sym_number] = ACTIONS(REDUCE(sym_range_statement, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_range_statement, 6)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_range_statement, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_range_statement, 6)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_range_statement, 6)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_range_statement, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_range_statement, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_range_statement, 6)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_range_statement, 6)),
     },
     [280] = {
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(282)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(282)),
     },
     [281] = {
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
     },
     [282] = {
+        [aux_sym_range] = ACTIONS(SHIFT(283)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_range] = ACTIONS(SHIFT(283)),
     },
     [283] = {
         [sym__expression] = ACTIONS(SHIFT(284)),
@@ -5745,31 +5745,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(215)),
         [sym_bool_op] = ACTIONS(SHIFT(215)),
         [sym_var_name] = ACTIONS(SHIFT(215)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(216)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(215)),
-        [sym__identifier] = ACTIONS(SHIFT(216)),
+        [sym__identifier] = ACTIONS(SHIFT(217)),
         [sym_number] = ACTIONS(SHIFT(215)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(217)),
     },
     [284] = {
         [sym_block_statement] = ACTIONS(SHIFT(285)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(220)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(269)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(222)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(223)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(222)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(224)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(224)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(225)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(226)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_LT] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(227)),
+        [aux_sym_GT] = ACTIONS(SHIFT(227)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(269)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(226)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(227)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(227)),
     },
     [285] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_range_statement, 8)),
@@ -5785,39 +5785,54 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_range_statement, 8)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_range_statement, 8)),
         [sym_var_name] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_range_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_range_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_range_statement, 8)),
         [sym__identifier] = ACTIONS(REDUCE(sym_range_statement, 8)),
         [sym_number] = ACTIONS(REDUCE(sym_range_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_range_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_range_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_range_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_range_statement, 8)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_range_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_range_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_range_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_range_statement, 8)),
     },
     [286] = {
-        [sym__line_break] = ACTIONS(SHIFT(287)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(288)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT(288)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(287)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [287] = {
+        [sym__expression] = ACTIONS(SHIFT(301)),
+        [sym_call_expression] = ACTIONS(SHIFT(238)),
+        [sym_selector_expression] = ACTIONS(SHIFT(238)),
+        [sym_math_op] = ACTIONS(SHIFT(238)),
+        [sym_bool_op] = ACTIONS(SHIFT(238)),
+        [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(302)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(238)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
+        [sym_number] = ACTIONS(SHIFT(238)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [288] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym__statement] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym_return_statement] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
@@ -5831,48 +5846,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym_var_name] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym__identifier] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym_number] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_short_var_declaration, 3)),
-    },
-    [288] = {
-        [sym__expression] = ACTIONS(SHIFT(301)),
-        [sym_call_expression] = ACTIONS(SHIFT(238)),
-        [sym_selector_expression] = ACTIONS(SHIFT(238)),
-        [sym_math_op] = ACTIONS(SHIFT(238)),
-        [sym_bool_op] = ACTIONS(SHIFT(238)),
-        [sym_var_name] = ACTIONS(SHIFT(238)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
-        [sym_number] = ACTIONS(SHIFT(238)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(302)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [289] = {
         [sym__expression] = ACTIONS(SHIFT(300)),
@@ -5881,12 +5881,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [290] = {
         [sym_var_name] = ACTIONS(SHIFT(299)),
@@ -5901,12 +5901,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [292] = {
         [sym__expression] = ACTIONS(SHIFT(297)),
@@ -5915,12 +5915,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [293] = {
         [sym__expression] = ACTIONS(SHIFT(296)),
@@ -5929,12 +5929,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [294] = {
         [sym__expression] = ACTIONS(SHIFT(295)),
@@ -5943,239 +5943,239 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [295] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
     },
     [296] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [297] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [298] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [299] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_selector_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
     },
     [300] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [301] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(303)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(244)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(304)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(246)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(247)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(248)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(246)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(250)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(303)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(244)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(304)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(247)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(248)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(250)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(251)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [302] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
     },
     [303] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(305)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(305)),
     },
     [304] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym__line_break] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
     },
     [305] = {
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym__line_break] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
     },
     [306] = {
-        [sym__line_break] = ACTIONS(SHIFT(312)),
+        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(312)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(313)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(314)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(315)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(316)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(317)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(315)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(319)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [sym__line_break] = ACTIONS(SHIFT(314)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(313)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(314)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(312)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(316)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(317)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(319)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(320)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(321)),
     },
     [307] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [308] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -6191,76 +6191,96 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_var_name] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym__identifier] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_number] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
     },
     [309] = {
-        [sym__line_break] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
-    },
-    [310] = {
         [sym__expression] = ACTIONS(SHIFT(311)),
         [sym_call_expression] = ACTIONS(SHIFT(307)),
         [sym_selector_expression] = ACTIONS(SHIFT(307)),
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
+    },
+    [310] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [311] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [312] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(335)),
+        [sym__line_break] = ACTIONS(SHIFT(335)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [313] = {
+        [sym__expression] = ACTIONS(SHIFT(330)),
+        [sym_call_expression] = ACTIONS(SHIFT(238)),
+        [sym_selector_expression] = ACTIONS(SHIFT(238)),
+        [sym_math_op] = ACTIONS(SHIFT(238)),
+        [sym_bool_op] = ACTIONS(SHIFT(238)),
+        [sym_var_name] = ACTIONS(SHIFT(238)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(331)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(240)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(238)),
+        [sym__identifier] = ACTIONS(SHIFT(241)),
+        [sym_number] = ACTIONS(SHIFT(238)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [314] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -6274,55 +6294,35 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_var_name] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym__identifier] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_number] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
-    },
-    [313] = {
-        [sym__line_break] = ACTIONS(SHIFT(335)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(335)),
-    },
-    [314] = {
-        [sym__expression] = ACTIONS(SHIFT(330)),
-        [sym_call_expression] = ACTIONS(SHIFT(238)),
-        [sym_selector_expression] = ACTIONS(SHIFT(238)),
-        [sym_math_op] = ACTIONS(SHIFT(238)),
-        [sym_bool_op] = ACTIONS(SHIFT(238)),
-        [sym_var_name] = ACTIONS(SHIFT(238)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(238)),
-        [sym__identifier] = ACTIONS(SHIFT(239)),
-        [sym_number] = ACTIONS(SHIFT(238)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(331)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(241)),
     },
     [315] = {
         [sym__expression] = ACTIONS(SHIFT(329)),
@@ -6331,12 +6331,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
     },
     [316] = {
         [sym__expression] = ACTIONS(SHIFT(327)),
@@ -6345,17 +6345,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
     },
     [317] = {
         [sym_var_name] = ACTIONS(SHIFT(326)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [318] = {
@@ -6365,12 +6365,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
     },
     [319] = {
         [sym__expression] = ACTIONS(SHIFT(324)),
@@ -6379,12 +6379,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
     },
     [320] = {
         [sym__expression] = ACTIONS(SHIFT(323)),
@@ -6393,12 +6393,12 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
     },
     [321] = {
         [sym__expression] = ACTIONS(SHIFT(322)),
@@ -6407,242 +6407,242 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(307)),
         [sym_bool_op] = ACTIONS(SHIFT(307)),
         [sym_var_name] = ACTIONS(SHIFT(307)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(309)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(307)),
-        [sym__identifier] = ACTIONS(SHIFT(309)),
+        [sym__identifier] = ACTIONS(SHIFT(310)),
         [sym_number] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(310)),
     },
     [322] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
     },
     [323] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(321)),
     },
     [324] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(315)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(315)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(320)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(321)),
     },
     [325] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(315)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(315)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(320)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(321)),
     },
     [326] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_selector_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_selector_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_selector_expression, 3)),
     },
     [327] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(328)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(313)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 2)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(315)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(316)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(317)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(315)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(319)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
         [sym__line_break] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(314)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(316)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(317)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(315)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(319)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(320)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(321)),
     },
     [328] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 3)),
         [sym__line_break] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(aux_sym_return_statement_repeat1, 3)),
     },
     [329] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(321)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(321)),
     },
     [330] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(332)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(244)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(333)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(246)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(247)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(248)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(246)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(250)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(SHIFT(332)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(244)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(333)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(247)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(248)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(246)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(249)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(250)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(251)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(252)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(252)),
     },
     [331] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_call_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 3)),
     },
     [332] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(334)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(334)),
     },
     [333] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym__line_break] = ACTIONS(REDUCE(sym_call_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 4)),
     },
     [334] = {
+        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym__line_break] = ACTIONS(REDUCE(sym_call_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_return_statement_repeat1] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE(sym_call_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_call_expression, 5)),
     },
     [335] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 4)),
@@ -6658,20 +6658,20 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 4)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 4)),
         [sym_var_name] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 4)),
         [sym__identifier] = ACTIONS(REDUCE(sym_return_statement, 4)),
         [sym_number] = ACTIONS(REDUCE(sym_return_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 4)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_return_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 4)),
     },
     [336] = {
         [sym__type_expression] = ACTIONS(SHIFT(338)),
@@ -6681,15 +6681,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(339)),
         [sym_interface_type] = ACTIONS(SHIFT(339)),
         [sym_type_name] = ACTIONS(SHIFT(339)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(340)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(341)),
+        [aux_sym_map] = ACTIONS(SHIFT(342)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(343)),
+        [aux_sym_struct] = ACTIONS(SHIFT(344)),
+        [aux_sym_interface] = ACTIONS(SHIFT(345)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(340)),
+        [sym__identifier] = ACTIONS(SHIFT(346)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(341)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(342)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(343)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(344)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(346)),
     },
     [337] = {
         [sym__type_expression] = ACTIONS(REDUCE(sym_var_name, 1)),
@@ -6699,49 +6699,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_interface_type] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_type_name] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_map] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_interface] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_map] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_interface] = ACTIONS(REDUCE(sym_var_name, 1)),
     },
     [338] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(364)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(365)),
         [sym__line_break] = ACTIONS(SHIFT(364)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(364)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(365)),
     },
     [339] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__type_expression, 1)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym__line_break] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__type_expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym__type_expression, 1)),
     },
     [340] = {
-        [sym__line_break] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_type_name, 1)),
-    },
-    [341] = {
         [sym__expression] = ACTIONS(SHIFT(362)),
         [sym_call_expression] = ACTIONS(SHIFT(201)),
         [sym_selector_expression] = ACTIONS(SHIFT(201)),
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
-    [342] = {
+    [341] = {
         [sym__type_expression] = ACTIONS(SHIFT(361)),
         [sym_pointer_type] = ACTIONS(SHIFT(339)),
         [sym_map_type] = ACTIONS(SHIFT(339)),
@@ -6749,84 +6743,90 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(339)),
         [sym_interface_type] = ACTIONS(SHIFT(339)),
         [sym_type_name] = ACTIONS(SHIFT(339)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(341)),
+        [aux_sym_map] = ACTIONS(SHIFT(342)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(343)),
+        [aux_sym_struct] = ACTIONS(SHIFT(344)),
+        [aux_sym_interface] = ACTIONS(SHIFT(345)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(346)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [342] = {
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(357)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(340)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(342)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(343)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(344)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(346)),
     },
     [343] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(355)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(357)),
     },
     [344] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(351)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(355)),
     },
     [345] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(347)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(351)),
     },
     [346] = {
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(347)),
     },
     [347] = {
         [sym_var_name] = ACTIONS(SHIFT(57)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(348)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(349)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(16)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(349)),
     },
     [348] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(350)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(350)),
     },
     [349] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_interface_type, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_interface_type, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_interface_type, 3)),
     },
     [350] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_interface_type, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym__line_break] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_interface_type, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_interface_type, 4)),
     },
     [351] = {
         [sym_var_name] = ACTIONS(SHIFT(112)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(113)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_struct_type_repeat1] = ACTIONS(SHIFT(352)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(353)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(353)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(115)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [352] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(354)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(354)),
     },
     [353] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_struct_type, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_struct_type, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_struct_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_struct_type, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_struct_type, 3)),
     },
     [354] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_struct_type, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym__line_break] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_struct_type, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_struct_type, 4)),
     },
     [355] = {
         [sym__type_expression] = ACTIONS(SHIFT(356)),
@@ -6836,20 +6836,20 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(339)),
         [sym_interface_type] = ACTIONS(SHIFT(339)),
         [sym_type_name] = ACTIONS(SHIFT(339)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(341)),
+        [aux_sym_map] = ACTIONS(SHIFT(342)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(343)),
+        [aux_sym_struct] = ACTIONS(SHIFT(344)),
+        [aux_sym_interface] = ACTIONS(SHIFT(345)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(340)),
+        [sym__identifier] = ACTIONS(SHIFT(346)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(342)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(343)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(344)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(346)),
     },
     [356] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_slice_type, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_slice_type, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_slice_type, 3)),
     },
     [357] = {
         [sym__type_expression] = ACTIONS(SHIFT(358)),
@@ -6859,19 +6859,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [358] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(359)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(359)),
     },
     [359] = {
         [sym__type_expression] = ACTIONS(SHIFT(360)),
@@ -6881,44 +6881,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(339)),
         [sym_interface_type] = ACTIONS(SHIFT(339)),
         [sym_type_name] = ACTIONS(SHIFT(339)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(341)),
+        [aux_sym_map] = ACTIONS(SHIFT(342)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(343)),
+        [aux_sym_struct] = ACTIONS(SHIFT(344)),
+        [aux_sym_interface] = ACTIONS(SHIFT(345)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(340)),
+        [sym__identifier] = ACTIONS(SHIFT(346)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(342)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(343)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(344)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(346)),
     },
     [360] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_map_type, 5)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym__line_break] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_map_type, 5)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_map_type, 5)),
     },
     [361] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_pointer_type, 2)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym__line_break] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_pointer_type, 2)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_pointer_type, 2)),
     },
     [362] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(363)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT(363)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(363)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [363] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 5)),
@@ -6934,33 +6934,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym_var_name] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym__identifier] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 5)),
     },
     [364] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -6976,21 +6976,21 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_var_name] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__identifier] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
     },
     [365] = {
         [sym__expression] = ACTIONS(SHIFT(366)),
@@ -6999,30 +6999,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [366] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(367)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT(367)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(367)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [367] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 6)),
@@ -7038,43 +7038,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym_var_name] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym__identifier] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 6)),
     },
     [368] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_block_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_block_statement, 3)),
     },
     [369] = {
+        [aux_sym_COLON_EQ] = ACTIONS(SHIFT(377)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(SHIFT(377)),
     },
     [370] = {
         [sym_var_name] = ACTIONS(SHIFT(374)),
@@ -7089,30 +7089,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [372] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(373)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT(373)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(373)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [373] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
@@ -7128,52 +7128,52 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
         [sym_var_name] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
         [sym__identifier] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
         [sym_number] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_short_var_declaration, 4)),
     },
     [374] = {
+        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(376)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(370)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_short_var_declaration_repeat1] = ACTIONS(SHIFT(376)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(370)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 2)),
     },
     [375] = {
+        [aux_sym_short_var_declaration_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_short_var_declaration_repeat1] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_var_name, 1)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_var_name, 1)),
     },
     [376] = {
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(aux_sym_short_var_declaration_repeat1, 3)),
     },
     [377] = {
         [sym__expression] = ACTIONS(SHIFT(378)),
@@ -7182,30 +7182,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [378] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(379)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT(379)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(379)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [379] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
@@ -7221,33 +7221,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
         [sym_var_name] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
         [sym__identifier] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
         [sym_number] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_short_var_declaration, 5)),
     },
     [380] = {
         [sym_var_declaration] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -7263,52 +7263,52 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_bool_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_var_name] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_COLON_EQ] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__identifier] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_number] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_block_statement_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_COLON_EQ] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
     },
     [381] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_block_statement_repeat1, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_block_statement_repeat1, 2)),
     },
     [382] = {
         [sym__declaration] = ACTIONS(REDUCE(sym_func_declaration, 5)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym_func_declaration, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_func_declaration, 5)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_func_declaration, 5)),
+        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_func_declaration, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_func_declaration, 5)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_func_declaration, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_func_declaration, 5)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_func_declaration, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_func_declaration, 5)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_func_declaration, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_func_declaration, 5)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_func_declaration, 5)),
     },
     [383] = {
         [sym__type_expression] = ACTIONS(SHIFT(384)),
@@ -7318,21 +7318,21 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(339)),
         [sym_interface_type] = ACTIONS(SHIFT(339)),
         [sym_type_name] = ACTIONS(SHIFT(339)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(385)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(341)),
+        [aux_sym_map] = ACTIONS(SHIFT(342)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(343)),
+        [aux_sym_struct] = ACTIONS(SHIFT(344)),
+        [aux_sym_interface] = ACTIONS(SHIFT(345)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(340)),
+        [sym__identifier] = ACTIONS(SHIFT(346)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(385)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(342)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(343)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(344)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(346)),
     },
     [384] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(388)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(389)),
         [sym__line_break] = ACTIONS(SHIFT(388)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(388)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(389)),
     },
     [385] = {
         [sym__expression] = ACTIONS(SHIFT(386)),
@@ -7341,72 +7341,72 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [386] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(387)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT(387)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(387)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [387] = {
         [sym__declaration] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_var_declaration, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_var_declaration, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_var_declaration, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
     },
     [388] = {
         [sym__declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_var_declaration, 4)),
     },
     [389] = {
         [sym__expression] = ACTIONS(SHIFT(390)),
@@ -7415,57 +7415,57 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(201)),
         [sym_bool_op] = ACTIONS(SHIFT(201)),
         [sym_var_name] = ACTIONS(SHIFT(201)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(210)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(201)),
         [sym__identifier] = ACTIONS(SHIFT(213)),
         [sym_number] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(211)),
     },
     [390] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(287)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(391)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(289)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(290)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(289)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(291)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(291)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(292)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(293)),
+        [aux_sym_EQ_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_LT] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT_EQ] = ACTIONS(SHIFT(294)),
+        [aux_sym_GT] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT(391)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(391)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(290)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(289)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(SHIFT(294)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(294)),
     },
     [391] = {
         [sym__declaration] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_var_declaration, 6)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_var_declaration, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_var_declaration, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
     },
     [392] = {
         [sym__type_expression] = ACTIONS(SHIFT(394)),
@@ -7475,14 +7475,14 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(395)),
         [sym_interface_type] = ACTIONS(SHIFT(395)),
         [sym_type_name] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_map] = ACTIONS(SHIFT(397)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(398)),
+        [aux_sym_struct] = ACTIONS(SHIFT(399)),
+        [aux_sym_interface] = ACTIONS(SHIFT(400)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(396)),
+        [sym__identifier] = ACTIONS(SHIFT(401)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(401)),
     },
     [393] = {
         [sym__type_expression] = ACTIONS(REDUCE(sym_type_name, 1)),
@@ -7492,31 +7492,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_interface_type] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_type_name] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_map] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_struct] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [aux_sym_interface] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_map] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_struct] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [aux_sym_STR_interface] = ACTIONS(REDUCE(sym_type_name, 1)),
     },
     [394] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(417)),
         [sym__line_break] = ACTIONS(SHIFT(417)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(417)),
     },
     [395] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym__line_break] = ACTIONS(REDUCE(sym__type_expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__type_expression, 1)),
     },
     [396] = {
-        [sym__line_break] = ACTIONS(REDUCE(sym_type_name, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_type_name, 1)),
-    },
-    [397] = {
         [sym__type_expression] = ACTIONS(SHIFT(416)),
         [sym_pointer_type] = ACTIONS(SHIFT(395)),
         [sym_map_type] = ACTIONS(SHIFT(395)),
@@ -7524,80 +7519,85 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(395)),
         [sym_interface_type] = ACTIONS(SHIFT(395)),
         [sym_type_name] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_map] = ACTIONS(SHIFT(397)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(398)),
+        [aux_sym_struct] = ACTIONS(SHIFT(399)),
+        [aux_sym_interface] = ACTIONS(SHIFT(400)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(401)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [397] = {
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(412)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(396)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(401)),
     },
     [398] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(410)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(412)),
     },
     [399] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(406)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(410)),
     },
     [400] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(402)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(406)),
     },
     [401] = {
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_type_name, 1)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_type_name, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(402)),
     },
     [402] = {
         [sym_var_name] = ACTIONS(SHIFT(57)),
+        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(403)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(404)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym__identifier] = ACTIONS(SHIFT(16)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_interface_type_repeat1] = ACTIONS(SHIFT(403)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(404)),
     },
     [403] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(405)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(405)),
     },
     [404] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_interface_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_interface_type, 3)),
     },
     [405] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym__line_break] = ACTIONS(REDUCE(sym_interface_type, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_interface_type, 4)),
     },
     [406] = {
         [sym_var_name] = ACTIONS(SHIFT(112)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(113)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_struct_type_repeat1] = ACTIONS(SHIFT(407)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(408)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(408)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym__identifier] = ACTIONS(SHIFT(115)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [407] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(409)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(409)),
     },
     [408] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_struct_type, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_struct_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_struct_type, 3)),
     },
     [409] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym__line_break] = ACTIONS(REDUCE(sym_struct_type, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_struct_type, 4)),
     },
     [410] = {
         [sym__type_expression] = ACTIONS(SHIFT(411)),
@@ -7607,19 +7607,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(395)),
         [sym_interface_type] = ACTIONS(SHIFT(395)),
         [sym_type_name] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_map] = ACTIONS(SHIFT(397)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(398)),
+        [aux_sym_struct] = ACTIONS(SHIFT(399)),
+        [aux_sym_interface] = ACTIONS(SHIFT(400)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(396)),
+        [sym__identifier] = ACTIONS(SHIFT(401)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(401)),
     },
     [411] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym__line_break] = ACTIONS(REDUCE(sym_slice_type, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_slice_type, 3)),
     },
     [412] = {
         [sym__type_expression] = ACTIONS(SHIFT(413)),
@@ -7629,19 +7629,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(137)),
         [sym_interface_type] = ACTIONS(SHIFT(137)),
         [sym_type_name] = ACTIONS(SHIFT(137)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(138)),
+        [aux_sym_map] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_struct] = ACTIONS(SHIFT(141)),
+        [aux_sym_interface] = ACTIONS(SHIFT(142)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(138)),
+        [sym__identifier] = ACTIONS(SHIFT(143)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(143)),
     },
     [413] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(414)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(414)),
     },
     [414] = {
         [sym__type_expression] = ACTIONS(SHIFT(415)),
@@ -7651,38 +7651,38 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_struct_type] = ACTIONS(SHIFT(395)),
         [sym_interface_type] = ACTIONS(SHIFT(395)),
         [sym_type_name] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_map] = ACTIONS(SHIFT(397)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(398)),
+        [aux_sym_struct] = ACTIONS(SHIFT(399)),
+        [aux_sym_interface] = ACTIONS(SHIFT(400)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym__identifier] = ACTIONS(SHIFT(396)),
+        [sym__identifier] = ACTIONS(SHIFT(401)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_map] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_struct] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_interface] = ACTIONS(SHIFT(401)),
     },
     [415] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym__line_break] = ACTIONS(REDUCE(sym_map_type, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_map_type, 5)),
     },
     [416] = {
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym__line_break] = ACTIONS(REDUCE(sym_pointer_type, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_pointer_type, 2)),
     },
     [417] = {
         [sym__declaration] = ACTIONS(REDUCE(sym_type_declaration, 4)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym_type_declaration, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_type_declaration, 4)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_type_declaration, 4)),
+        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_type_declaration, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_type_declaration, 4)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_type_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_type_declaration, 4)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_type_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_type_declaration, 4)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_type_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_type_declaration, 4)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_type_declaration, 4)),
     },
     [418] = {
         [sym_imports_block] = ACTIONS(REDUCE(sym_imports_block, 2)),
@@ -7690,77 +7690,77 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_declaration] = ACTIONS(REDUCE(sym_imports_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_imports_block, 2)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_imports_block, 2)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_imports_block, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_imports_block, 2)),
         [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_imports_block, 2)),
-        [aux_sym_STR_import] = ACTIONS(REDUCE(sym_imports_block, 2)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_imports_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_imports_block, 2)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_imports_block, 2)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_imports_block, 2)),
+        [aux_sym_import] = ACTIONS(REDUCE(sym_imports_block, 2)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_imports_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_imports_block, 2)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_imports_block, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [419] = {
+        [sym_package_import] = ACTIONS(SHIFT(421)),
+        [aux_sym_imports_block_repeat1] = ACTIONS(SHIFT(422)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(422)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(423)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(424)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [420] = {
         [sym_imports_block] = ACTIONS(REDUCE(sym_package_import, 1)),
         [sym__declaration] = ACTIONS(REDUCE(sym_package_import, 1)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym_package_import, 1)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_package_import, 1)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_package_import, 1)),
         [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [aux_sym_STR_import] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_package_import, 1)),
-    },
-    [420] = {
-        [sym_package_import] = ACTIONS(SHIFT(421)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(422)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [aux_sym_import] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_package_import, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(423)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_imports_block_repeat1] = ACTIONS(SHIFT(422)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(424)),
     },
     [421] = {
         [sym_package_import] = ACTIONS(SHIFT(421)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(423)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_imports_block_repeat1] = ACTIONS(SHIFT(426)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_imports_block_repeat1, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_imports_block_repeat1, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(424)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [422] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(425)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(425)),
     },
     [423] = {
-        [sym_package_import] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_imports_block_repeat1] = ACTIONS(REDUCE(sym_package_import, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_package_import, 1)),
-    },
-    [424] = {
         [sym_imports_block] = ACTIONS(REDUCE(sym_imports_block, 3)),
         [sym__declaration] = ACTIONS(REDUCE(sym_imports_block, 3)),
         [sym_type_declaration] = ACTIONS(REDUCE(sym_imports_block, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_imports_block, 3)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_imports_block, 3)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_imports_block, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_imports_block, 3)),
         [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_imports_block, 3)),
-        [aux_sym_STR_import] = ACTIONS(REDUCE(sym_imports_block, 3)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_imports_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_imports_block, 3)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_imports_block, 3)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_imports_block, 3)),
+        [aux_sym_import] = ACTIONS(REDUCE(sym_imports_block, 3)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_imports_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_imports_block, 3)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_imports_block, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [424] = {
+        [sym_package_import] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [aux_sym_imports_block_repeat1] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_package_import, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
     },
     [425] = {
         [sym_imports_block] = ACTIONS(REDUCE(sym_imports_block, 4)),
@@ -7768,20 +7768,20 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_declaration] = ACTIONS(REDUCE(sym_imports_block, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_imports_block, 4)),
         [sym_func_declaration] = ACTIONS(REDUCE(sym_imports_block, 4)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_imports_block, 4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_imports_block, 4)),
         [aux_sym_program_repeat2] = ACTIONS(REDUCE(sym_imports_block, 4)),
-        [aux_sym_STR_import] = ACTIONS(REDUCE(sym_imports_block, 4)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(sym_imports_block, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_imports_block, 4)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(sym_imports_block, 4)),
-    },
-    [426] = {
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_imports_block, 4)),
+        [aux_sym_import] = ACTIONS(REDUCE(sym_imports_block, 4)),
+        [aux_sym_type] = ACTIONS(REDUCE(sym_imports_block, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_imports_block, 4)),
+        [aux_sym_func] = ACTIONS(REDUCE(sym_imports_block, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [426] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_imports_block_repeat1, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_imports_block_repeat1, 2)),
     },
     [427] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 3)),
@@ -7798,13 +7798,13 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_type_declaration] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [sym_func_declaration] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
+        [aux_sym_program_repeat2] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
+        [aux_sym_type] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
+        [aux_sym_func] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat2] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-        [aux_sym_STR_type] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-        [aux_sym_STR_func] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
     },
 };
 
diff --git a/spec/fixtures/parsers/javascript.c b/spec/fixtures/parsers/javascript.c
index 37734ef3..8494204c 100644
--- a/spec/fixtures/parsers/javascript.c
+++ b/spec/fixtures/parsers/javascript.c
@@ -43,6 +43,61 @@ enum {
     sym_formal_parameters,
     sym_arguments,
     sym_pair,
+    aux_sym_program_repeat1,
+    aux_sym_var_declaration_repeat1,
+    aux_sym_switch_statement_repeat1,
+    aux_sym_object_repeat1,
+    aux_sym_array_repeat1,
+    aux_sym_formal_parameters_repeat1,
+    aux_sym_SEMI,
+    aux_sym_var,
+    aux_sym_COMMA,
+    aux_sym_LBRACE,
+    aux_sym_RBRACE,
+    aux_sym_if,
+    aux_sym_else,
+    aux_sym_switch,
+    aux_sym_for,
+    aux_sym_LPAREN,
+    aux_sym_RPAREN,
+    aux_sym_in,
+    aux_sym_while,
+    aux_sym_try,
+    aux_sym_return,
+    aux_sym_throw,
+    aux_sym_break,
+    aux_sym_delete,
+    aux_sym_case,
+    aux_sym_COLON,
+    aux_sym_default,
+    aux_sym_catch,
+    aux_sym_finally,
+    aux_sym_EQ,
+    aux_sym_LBRACK,
+    aux_sym_RBRACK,
+    aux_sym_function,
+    aux_sym_new,
+    aux_sym_DOT,
+    aux_sym_PLUS_EQ,
+    aux_sym_DASH_EQ,
+    aux_sym_STAR_EQ,
+    aux_sym_SLASH_EQ,
+    aux_sym_QMARK,
+    aux_sym_PIPE_PIPE,
+    aux_sym_AMP_AMP,
+    aux_sym_BANG,
+    aux_sym_PLUS_PLUS,
+    aux_sym_DASH_DASH,
+    aux_sym_STAR,
+    aux_sym_SLASH,
+    aux_sym_PLUS,
+    aux_sym_DASH,
+    aux_sym_EQ_EQ_EQ,
+    aux_sym_BANG_EQ_EQ,
+    aux_sym_LT,
+    aux_sym_GT,
+    aux_sym_instanceof,
+    aux_sym_typeof,
     sym_comment,
     sym_string,
     sym_regex,
@@ -53,61 +108,6 @@ enum {
     sym_true,
     sym_false,
     sym__line_break,
-    aux_sym_program_repeat1,
-    aux_sym_var_declaration_repeat1,
-    aux_sym_switch_statement_repeat1,
-    aux_sym_object_repeat1,
-    aux_sym_array_repeat1,
-    aux_sym_formal_parameters_repeat1,
-    aux_sym_STR_SEMI,
-    aux_sym_STR_var,
-    aux_sym_STR_COMMA,
-    aux_sym_STR_LBRACE,
-    aux_sym_STR_RBRACE,
-    aux_sym_STR_if,
-    aux_sym_STR_else,
-    aux_sym_STR_switch,
-    aux_sym_STR_for,
-    aux_sym_STR_LPAREN,
-    aux_sym_STR_RPAREN,
-    aux_sym_STR_in,
-    aux_sym_STR_while,
-    aux_sym_STR_try,
-    aux_sym_STR_return,
-    aux_sym_STR_throw,
-    aux_sym_STR_break,
-    aux_sym_STR_delete,
-    aux_sym_STR_case,
-    aux_sym_STR_COLON,
-    aux_sym_STR_default,
-    aux_sym_STR_catch,
-    aux_sym_STR_finally,
-    aux_sym_STR_EQ,
-    aux_sym_STR_LBRACK,
-    aux_sym_STR_RBRACK,
-    aux_sym_STR_function,
-    aux_sym_STR_new,
-    aux_sym_STR_DOT,
-    aux_sym_STR_PLUS_EQ,
-    aux_sym_STR_DASH_EQ,
-    aux_sym_STR_STAR_EQ,
-    aux_sym_STR_SLASH_EQ,
-    aux_sym_STR_QMARK,
-    aux_sym_STR_PIPE_PIPE,
-    aux_sym_STR_AMP_AMP,
-    aux_sym_STR_BANG,
-    aux_sym_STR_PLUS_PLUS,
-    aux_sym_STR_DASH_DASH,
-    aux_sym_STR_STAR,
-    aux_sym_STR_SLASH,
-    aux_sym_STR_PLUS,
-    aux_sym_STR_DASH,
-    aux_sym_STR_EQ_EQ_EQ,
-    aux_sym_STR_BANG_EQ_EQ,
-    aux_sym_STR_LT,
-    aux_sym_STR_GT,
-    aux_sym_STR_instanceof,
-    aux_sym_STR_typeof,
 };
 
 static const char *ts_symbol_names[] = {
@@ -150,8 +150,63 @@ static const char *ts_symbol_names[] = {
     [sym_formal_parameters] = "formal_parameters",
     [sym_arguments] = "arguments",
     [sym_pair] = "pair",
+    [aux_sym_program_repeat1] = "program_repeat1",
+    [aux_sym_var_declaration_repeat1] = "var_declaration_repeat1",
+    [aux_sym_switch_statement_repeat1] = "switch_statement_repeat1",
+    [aux_sym_object_repeat1] = "object_repeat1",
+    [aux_sym_array_repeat1] = "array_repeat1",
+    [aux_sym_formal_parameters_repeat1] = "formal_parameters_repeat1",
     [ts_builtin_sym_error] = "ERROR",
     [ts_builtin_sym_end] = "END",
+    [aux_sym_SEMI] = ";",
+    [aux_sym_var] = "var",
+    [aux_sym_COMMA] = ",",
+    [aux_sym_LBRACE] = "{",
+    [aux_sym_RBRACE] = "}",
+    [aux_sym_if] = "if",
+    [aux_sym_else] = "else",
+    [aux_sym_switch] = "switch",
+    [aux_sym_for] = "for",
+    [aux_sym_LPAREN] = "(",
+    [aux_sym_RPAREN] = ")",
+    [aux_sym_in] = "in",
+    [aux_sym_while] = "while",
+    [aux_sym_try] = "try",
+    [aux_sym_return] = "return",
+    [aux_sym_throw] = "throw",
+    [aux_sym_break] = "break",
+    [aux_sym_delete] = "delete",
+    [aux_sym_case] = "case",
+    [aux_sym_COLON] = ":",
+    [aux_sym_default] = "default",
+    [aux_sym_catch] = "catch",
+    [aux_sym_finally] = "finally",
+    [aux_sym_EQ] = "=",
+    [aux_sym_LBRACK] = "[",
+    [aux_sym_RBRACK] = "]",
+    [aux_sym_function] = "function",
+    [aux_sym_new] = "new",
+    [aux_sym_DOT] = ".",
+    [aux_sym_PLUS_EQ] = "+=",
+    [aux_sym_DASH_EQ] = "-=",
+    [aux_sym_STAR_EQ] = "*=",
+    [aux_sym_SLASH_EQ] = "/=",
+    [aux_sym_QMARK] = "?",
+    [aux_sym_PIPE_PIPE] = "||",
+    [aux_sym_AMP_AMP] = "&&",
+    [aux_sym_BANG] = "!",
+    [aux_sym_PLUS_PLUS] = "++",
+    [aux_sym_DASH_DASH] = "--",
+    [aux_sym_STAR] = "*",
+    [aux_sym_SLASH] = "/",
+    [aux_sym_PLUS] = "+",
+    [aux_sym_DASH] = "-",
+    [aux_sym_EQ_EQ_EQ] = "===",
+    [aux_sym_BANG_EQ_EQ] = "!==",
+    [aux_sym_LT] = "<",
+    [aux_sym_GT] = ">",
+    [aux_sym_instanceof] = "instanceof",
+    [aux_sym_typeof] = "typeof",
     [sym_comment] = "comment",
     [sym_string] = "string",
     [sym_regex] = "regex",
@@ -162,123 +217,68 @@ static const char *ts_symbol_names[] = {
     [sym_true] = "true",
     [sym_false] = "false",
     [sym__line_break] = "_line_break",
-    [aux_sym_program_repeat1] = "program_repeat1",
-    [aux_sym_var_declaration_repeat1] = "var_declaration_repeat1",
-    [aux_sym_switch_statement_repeat1] = "switch_statement_repeat1",
-    [aux_sym_object_repeat1] = "object_repeat1",
-    [aux_sym_array_repeat1] = "array_repeat1",
-    [aux_sym_formal_parameters_repeat1] = "formal_parameters_repeat1",
-    [aux_sym_STR_SEMI] = "STR_;",
-    [aux_sym_STR_var] = "STR_var",
-    [aux_sym_STR_COMMA] = "STR_,",
-    [aux_sym_STR_LBRACE] = "STR_{",
-    [aux_sym_STR_RBRACE] = "STR_}",
-    [aux_sym_STR_if] = "STR_if",
-    [aux_sym_STR_else] = "STR_else",
-    [aux_sym_STR_switch] = "STR_switch",
-    [aux_sym_STR_for] = "STR_for",
-    [aux_sym_STR_LPAREN] = "STR_(",
-    [aux_sym_STR_RPAREN] = "STR_)",
-    [aux_sym_STR_in] = "STR_in",
-    [aux_sym_STR_while] = "STR_while",
-    [aux_sym_STR_try] = "STR_try",
-    [aux_sym_STR_return] = "STR_return",
-    [aux_sym_STR_throw] = "STR_throw",
-    [aux_sym_STR_break] = "STR_break",
-    [aux_sym_STR_delete] = "STR_delete",
-    [aux_sym_STR_case] = "STR_case",
-    [aux_sym_STR_COLON] = "STR_:",
-    [aux_sym_STR_default] = "STR_default",
-    [aux_sym_STR_catch] = "STR_catch",
-    [aux_sym_STR_finally] = "STR_finally",
-    [aux_sym_STR_EQ] = "STR_=",
-    [aux_sym_STR_LBRACK] = "STR_[",
-    [aux_sym_STR_RBRACK] = "STR_]",
-    [aux_sym_STR_function] = "STR_function",
-    [aux_sym_STR_new] = "STR_new",
-    [aux_sym_STR_DOT] = "STR_.",
-    [aux_sym_STR_PLUS_EQ] = "STR_+=",
-    [aux_sym_STR_DASH_EQ] = "STR_-=",
-    [aux_sym_STR_STAR_EQ] = "STR_*=",
-    [aux_sym_STR_SLASH_EQ] = "STR_/=",
-    [aux_sym_STR_QMARK] = "STR_?",
-    [aux_sym_STR_PIPE_PIPE] = "STR_||",
-    [aux_sym_STR_AMP_AMP] = "STR_&&",
-    [aux_sym_STR_BANG] = "STR_!",
-    [aux_sym_STR_PLUS_PLUS] = "STR_++",
-    [aux_sym_STR_DASH_DASH] = "STR_--",
-    [aux_sym_STR_STAR] = "STR_*",
-    [aux_sym_STR_SLASH] = "STR_/",
-    [aux_sym_STR_PLUS] = "STR_+",
-    [aux_sym_STR_DASH] = "STR_-",
-    [aux_sym_STR_EQ_EQ_EQ] = "STR_===",
-    [aux_sym_STR_BANG_EQ_EQ] = "STR_!==",
-    [aux_sym_STR_LT] = "STR_<",
-    [aux_sym_STR_GT] = "STR_>",
-    [aux_sym_STR_instanceof] = "STR_instanceof",
-    [aux_sym_STR_typeof] = "STR_typeof",
 };
 
 static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
     [sym__statement] = 1,
     [sym__paren_expression] = 1,
     [sym__expression] = 1,
-    [sym__line_break] = 1,
     [aux_sym_program_repeat1] = 1,
     [aux_sym_var_declaration_repeat1] = 1,
     [aux_sym_switch_statement_repeat1] = 1,
     [aux_sym_object_repeat1] = 1,
     [aux_sym_array_repeat1] = 1,
     [aux_sym_formal_parameters_repeat1] = 1,
-    [aux_sym_STR_SEMI] = 1,
-    [aux_sym_STR_var] = 1,
-    [aux_sym_STR_COMMA] = 1,
-    [aux_sym_STR_LBRACE] = 1,
-    [aux_sym_STR_RBRACE] = 1,
-    [aux_sym_STR_if] = 1,
-    [aux_sym_STR_else] = 1,
-    [aux_sym_STR_switch] = 1,
-    [aux_sym_STR_for] = 1,
-    [aux_sym_STR_LPAREN] = 1,
-    [aux_sym_STR_RPAREN] = 1,
-    [aux_sym_STR_in] = 1,
-    [aux_sym_STR_while] = 1,
-    [aux_sym_STR_try] = 1,
-    [aux_sym_STR_return] = 1,
-    [aux_sym_STR_throw] = 1,
-    [aux_sym_STR_break] = 1,
-    [aux_sym_STR_delete] = 1,
-    [aux_sym_STR_case] = 1,
-    [aux_sym_STR_COLON] = 1,
-    [aux_sym_STR_default] = 1,
-    [aux_sym_STR_catch] = 1,
-    [aux_sym_STR_finally] = 1,
-    [aux_sym_STR_EQ] = 1,
-    [aux_sym_STR_LBRACK] = 1,
-    [aux_sym_STR_RBRACK] = 1,
-    [aux_sym_STR_function] = 1,
-    [aux_sym_STR_new] = 1,
-    [aux_sym_STR_DOT] = 1,
-    [aux_sym_STR_PLUS_EQ] = 1,
-    [aux_sym_STR_DASH_EQ] = 1,
-    [aux_sym_STR_STAR_EQ] = 1,
-    [aux_sym_STR_SLASH_EQ] = 1,
-    [aux_sym_STR_QMARK] = 1,
-    [aux_sym_STR_PIPE_PIPE] = 1,
-    [aux_sym_STR_AMP_AMP] = 1,
-    [aux_sym_STR_BANG] = 1,
-    [aux_sym_STR_PLUS_PLUS] = 1,
-    [aux_sym_STR_DASH_DASH] = 1,
-    [aux_sym_STR_STAR] = 1,
-    [aux_sym_STR_SLASH] = 1,
-    [aux_sym_STR_PLUS] = 1,
-    [aux_sym_STR_DASH] = 1,
-    [aux_sym_STR_EQ_EQ_EQ] = 1,
-    [aux_sym_STR_BANG_EQ_EQ] = 1,
-    [aux_sym_STR_LT] = 1,
-    [aux_sym_STR_GT] = 1,
-    [aux_sym_STR_instanceof] = 1,
-    [aux_sym_STR_typeof] = 1,
+    [aux_sym_SEMI] = 1,
+    [aux_sym_var] = 1,
+    [aux_sym_COMMA] = 1,
+    [aux_sym_LBRACE] = 1,
+    [aux_sym_RBRACE] = 1,
+    [aux_sym_if] = 1,
+    [aux_sym_else] = 1,
+    [aux_sym_switch] = 1,
+    [aux_sym_for] = 1,
+    [aux_sym_LPAREN] = 1,
+    [aux_sym_RPAREN] = 1,
+    [aux_sym_in] = 1,
+    [aux_sym_while] = 1,
+    [aux_sym_try] = 1,
+    [aux_sym_return] = 1,
+    [aux_sym_throw] = 1,
+    [aux_sym_break] = 1,
+    [aux_sym_delete] = 1,
+    [aux_sym_case] = 1,
+    [aux_sym_COLON] = 1,
+    [aux_sym_default] = 1,
+    [aux_sym_catch] = 1,
+    [aux_sym_finally] = 1,
+    [aux_sym_EQ] = 1,
+    [aux_sym_LBRACK] = 1,
+    [aux_sym_RBRACK] = 1,
+    [aux_sym_function] = 1,
+    [aux_sym_new] = 1,
+    [aux_sym_DOT] = 1,
+    [aux_sym_PLUS_EQ] = 1,
+    [aux_sym_DASH_EQ] = 1,
+    [aux_sym_STAR_EQ] = 1,
+    [aux_sym_SLASH_EQ] = 1,
+    [aux_sym_QMARK] = 1,
+    [aux_sym_PIPE_PIPE] = 1,
+    [aux_sym_AMP_AMP] = 1,
+    [aux_sym_BANG] = 1,
+    [aux_sym_PLUS_PLUS] = 1,
+    [aux_sym_DASH_DASH] = 1,
+    [aux_sym_STAR] = 1,
+    [aux_sym_SLASH] = 1,
+    [aux_sym_PLUS] = 1,
+    [aux_sym_DASH] = 1,
+    [aux_sym_EQ_EQ_EQ] = 1,
+    [aux_sym_BANG_EQ_EQ] = 1,
+    [aux_sym_LT] = 1,
+    [aux_sym_GT] = 1,
+    [aux_sym_instanceof] = 1,
+    [aux_sym_typeof] = 1,
+    [sym__line_break] = 1,
 };
 
 static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@@ -350,7 +350,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
         case 3:
             ACCEPT_TOKEN(sym__line_break);
         case 4:
-            ACCEPT_TOKEN(aux_sym_STR_BANG);
+            ACCEPT_TOKEN(aux_sym_BANG);
         case 5:
             if (lookahead == '\"')
                 ADVANCE(6);
@@ -442,7 +442,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(14);
             LEX_ERROR();
         case 15:
-            ACCEPT_TOKEN(aux_sym_STR_LPAREN);
+            ACCEPT_TOKEN(aux_sym_LPAREN);
         case 16:
             if (lookahead == '*')
                 ADVANCE(17);
@@ -653,7 +653,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(40);
             ACCEPT_TOKEN(sym_number);
         case 41:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACK);
+            ACCEPT_TOKEN(aux_sym_LBRACK);
         case 42:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -704,7 +704,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_break);
+            ACCEPT_TOKEN(aux_sym_break);
         case 47:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -767,7 +767,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_delete);
+            ACCEPT_TOKEN(aux_sym_delete);
         case 53:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -843,7 +843,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_for);
+            ACCEPT_TOKEN(aux_sym_for);
         case 60:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -918,7 +918,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_function);
+            ACCEPT_TOKEN(aux_sym_function);
         case 67:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -937,7 +937,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_if);
+            ACCEPT_TOKEN(aux_sym_if);
         case 69:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -970,7 +970,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_new);
+            ACCEPT_TOKEN(aux_sym_new);
         case 72:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -1063,7 +1063,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_return);
+            ACCEPT_TOKEN(aux_sym_return);
         case 81:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -1127,7 +1127,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_switch);
+            ACCEPT_TOKEN(aux_sym_switch);
         case 87:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -1185,7 +1185,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_throw);
+            ACCEPT_TOKEN(aux_sym_throw);
         case 92:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -1226,7 +1226,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_try);
+            ACCEPT_TOKEN(aux_sym_try);
         case 96:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -1278,7 +1278,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_typeof);
+            ACCEPT_TOKEN(aux_sym_typeof);
         case 101:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -1403,7 +1403,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_var);
+            ACCEPT_TOKEN(aux_sym_var);
         case 113:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -1455,9 +1455,9 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_while);
+            ACCEPT_TOKEN(aux_sym_while);
         case 118:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACE);
+            ACCEPT_TOKEN(aux_sym_LBRACE);
         case 119:
             START_TOKEN();
             if (lookahead == 0)
@@ -1534,39 +1534,39 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(125);
             LEX_ERROR();
         case 125:
-            ACCEPT_TOKEN(aux_sym_STR_BANG_EQ_EQ);
+            ACCEPT_TOKEN(aux_sym_BANG_EQ_EQ);
         case 126:
             if (lookahead == '&')
                 ADVANCE(127);
             LEX_ERROR();
         case 127:
-            ACCEPT_TOKEN(aux_sym_STR_AMP_AMP);
+            ACCEPT_TOKEN(aux_sym_AMP_AMP);
         case 128:
-            ACCEPT_TOKEN(aux_sym_STR_STAR);
+            ACCEPT_TOKEN(aux_sym_STAR);
         case 129:
             if (lookahead == '+')
                 ADVANCE(130);
-            ACCEPT_TOKEN(aux_sym_STR_PLUS);
+            ACCEPT_TOKEN(aux_sym_PLUS);
         case 130:
-            ACCEPT_TOKEN(aux_sym_STR_PLUS_PLUS);
+            ACCEPT_TOKEN(aux_sym_PLUS_PLUS);
         case 131:
             if (lookahead == '-')
                 ADVANCE(132);
-            ACCEPT_TOKEN(aux_sym_STR_DASH);
+            ACCEPT_TOKEN(aux_sym_DASH);
         case 132:
-            ACCEPT_TOKEN(aux_sym_STR_DASH_DASH);
+            ACCEPT_TOKEN(aux_sym_DASH_DASH);
         case 133:
-            ACCEPT_TOKEN(aux_sym_STR_DOT);
+            ACCEPT_TOKEN(aux_sym_DOT);
         case 134:
             if (lookahead == '*')
                 ADVANCE(121);
             if (lookahead == '/')
                 ADVANCE(32);
-            ACCEPT_TOKEN(aux_sym_STR_SLASH);
+            ACCEPT_TOKEN(aux_sym_SLASH);
         case 135:
-            ACCEPT_TOKEN(aux_sym_STR_SEMI);
+            ACCEPT_TOKEN(aux_sym_SEMI);
         case 136:
-            ACCEPT_TOKEN(aux_sym_STR_LT);
+            ACCEPT_TOKEN(aux_sym_LT);
         case 137:
             if (lookahead == '=')
                 ADVANCE(138);
@@ -1576,11 +1576,11 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(139);
             LEX_ERROR();
         case 139:
-            ACCEPT_TOKEN(aux_sym_STR_EQ_EQ_EQ);
+            ACCEPT_TOKEN(aux_sym_EQ_EQ_EQ);
         case 140:
-            ACCEPT_TOKEN(aux_sym_STR_GT);
+            ACCEPT_TOKEN(aux_sym_GT);
         case 141:
-            ACCEPT_TOKEN(aux_sym_STR_QMARK);
+            ACCEPT_TOKEN(aux_sym_QMARK);
         case 142:
             if (lookahead == 'n')
                 ADVANCE(143);
@@ -1588,7 +1588,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
         case 143:
             if (lookahead == 's')
                 ADVANCE(144);
-            ACCEPT_TOKEN(aux_sym_STR_in);
+            ACCEPT_TOKEN(aux_sym_in);
         case 144:
             if (lookahead == 't')
                 ADVANCE(145);
@@ -1618,13 +1618,13 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(151);
             LEX_ERROR();
         case 151:
-            ACCEPT_TOKEN(aux_sym_STR_instanceof);
+            ACCEPT_TOKEN(aux_sym_instanceof);
         case 152:
             if (lookahead == '|')
                 ADVANCE(153);
             LEX_ERROR();
         case 153:
-            ACCEPT_TOKEN(aux_sym_STR_PIPE_PIPE);
+            ACCEPT_TOKEN(aux_sym_PIPE_PIPE);
         case 154:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1669,25 +1669,25 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
         case 155:
             if (lookahead == '=')
                 ADVANCE(156);
-            ACCEPT_TOKEN(aux_sym_STR_STAR);
+            ACCEPT_TOKEN(aux_sym_STAR);
         case 156:
-            ACCEPT_TOKEN(aux_sym_STR_STAR_EQ);
+            ACCEPT_TOKEN(aux_sym_STAR_EQ);
         case 157:
             if (lookahead == '+')
                 ADVANCE(130);
             if (lookahead == '=')
                 ADVANCE(158);
-            ACCEPT_TOKEN(aux_sym_STR_PLUS);
+            ACCEPT_TOKEN(aux_sym_PLUS);
         case 158:
-            ACCEPT_TOKEN(aux_sym_STR_PLUS_EQ);
+            ACCEPT_TOKEN(aux_sym_PLUS_EQ);
         case 159:
             if (lookahead == '-')
                 ADVANCE(132);
             if (lookahead == '=')
                 ADVANCE(160);
-            ACCEPT_TOKEN(aux_sym_STR_DASH);
+            ACCEPT_TOKEN(aux_sym_DASH);
         case 160:
-            ACCEPT_TOKEN(aux_sym_STR_DASH_EQ);
+            ACCEPT_TOKEN(aux_sym_DASH_EQ);
         case 161:
             if (lookahead == '*')
                 ADVANCE(121);
@@ -1695,13 +1695,13 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(32);
             if (lookahead == '=')
                 ADVANCE(162);
-            ACCEPT_TOKEN(aux_sym_STR_SLASH);
+            ACCEPT_TOKEN(aux_sym_SLASH);
         case 162:
-            ACCEPT_TOKEN(aux_sym_STR_SLASH_EQ);
+            ACCEPT_TOKEN(aux_sym_SLASH_EQ);
         case 163:
             if (lookahead == '=')
                 ADVANCE(138);
-            ACCEPT_TOKEN(aux_sym_STR_EQ);
+            ACCEPT_TOKEN(aux_sym_EQ);
         case 164:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1793,7 +1793,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(167);
             LEX_ERROR();
         case 167:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACE);
+            ACCEPT_TOKEN(aux_sym_RBRACE);
         case 168:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -1986,7 +1986,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(118);
             LEX_ERROR();
         case 176:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACK);
+            ACCEPT_TOKEN(aux_sym_RBRACK);
         case 177:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -2043,7 +2043,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(167);
             LEX_ERROR();
         case 180:
-            ACCEPT_TOKEN(aux_sym_STR_COMMA);
+            ACCEPT_TOKEN(aux_sym_COMMA);
         case 181:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -2058,7 +2058,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(182);
             LEX_ERROR();
         case 182:
-            ACCEPT_TOKEN(aux_sym_STR_COLON);
+            ACCEPT_TOKEN(aux_sym_COLON);
         case 183:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -2189,7 +2189,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(118);
             LEX_ERROR();
         case 186:
-            ACCEPT_TOKEN(aux_sym_STR_RPAREN);
+            ACCEPT_TOKEN(aux_sym_RPAREN);
         case 187:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -2214,6 +2214,8 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(133);
             if (lookahead == '/')
                 ADVANCE(134);
+            if (lookahead == ':')
+                ADVANCE(182);
             if (lookahead == '<')
                 ADVANCE(136);
             if (lookahead == '=')
@@ -2224,8 +2226,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(141);
             if (lookahead == '[')
                 ADVANCE(41);
-            if (lookahead == ']')
-                ADVANCE(176);
             if (lookahead == 'i')
                 ADVANCE(142);
             if (lookahead == '|')
@@ -2255,6 +2255,8 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(133);
             if (lookahead == '/')
                 ADVANCE(161);
+            if (lookahead == ':')
+                ADVANCE(182);
             if (lookahead == '<')
                 ADVANCE(136);
             if (lookahead == '=')
@@ -2265,8 +2267,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(141);
             if (lookahead == '[')
                 ADVANCE(41);
-            if (lookahead == ']')
-                ADVANCE(176);
             if (lookahead == 'i')
                 ADVANCE(142);
             if (lookahead == '|')
@@ -2280,19 +2280,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(189);
             if (lookahead == '\n')
                 ADVANCE(3);
-            if (lookahead == '/')
-                ADVANCE(120);
-            if (lookahead == ']')
-                ADVANCE(176);
-            LEX_ERROR();
-        case 190:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(190);
-            if (lookahead == '\n')
-                ADVANCE(3);
             if (lookahead == '!')
                 ADVANCE(123);
             if (lookahead == '&')
@@ -2309,8 +2296,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(133);
             if (lookahead == '/')
                 ADVANCE(134);
-            if (lookahead == ':')
-                ADVANCE(182);
             if (lookahead == '<')
                 ADVANCE(136);
             if (lookahead == '=')
@@ -2321,17 +2306,19 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(141);
             if (lookahead == '[')
                 ADVANCE(41);
+            if (lookahead == ']')
+                ADVANCE(176);
             if (lookahead == 'i')
                 ADVANCE(142);
             if (lookahead == '|')
                 ADVANCE(152);
             LEX_ERROR();
-        case 191:
+        case 190:
             START_TOKEN();
             if ((lookahead == '\t') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
-                ADVANCE(191);
+                ADVANCE(190);
             if (lookahead == '\n')
                 ADVANCE(3);
             if (lookahead == '!')
@@ -2350,8 +2337,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(133);
             if (lookahead == '/')
                 ADVANCE(161);
-            if (lookahead == ':')
-                ADVANCE(182);
             if (lookahead == '<')
                 ADVANCE(136);
             if (lookahead == '=')
@@ -2362,11 +2347,26 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(141);
             if (lookahead == '[')
                 ADVANCE(41);
+            if (lookahead == ']')
+                ADVANCE(176);
             if (lookahead == 'i')
                 ADVANCE(142);
             if (lookahead == '|')
                 ADVANCE(152);
             LEX_ERROR();
+        case 191:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(191);
+            if (lookahead == '\n')
+                ADVANCE(3);
+            if (lookahead == '/')
+                ADVANCE(120);
+            if (lookahead == ']')
+                ADVANCE(176);
+            LEX_ERROR();
         case 192:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -2509,8 +2509,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(3);
             if (lookahead == '/')
                 ADVANCE(120);
-            if (lookahead == ';')
-                ADVANCE(135);
             if (lookahead == '}')
                 ADVANCE(167);
             LEX_ERROR();
@@ -2524,6 +2522,8 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(3);
             if (lookahead == '/')
                 ADVANCE(120);
+            if (lookahead == ';')
+                ADVANCE(135);
             if (lookahead == '}')
                 ADVANCE(167);
             LEX_ERROR();
@@ -2693,7 +2693,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
         case 202:
             if (lookahead == '=')
                 ADVANCE(124);
-            ACCEPT_TOKEN(aux_sym_STR_BANG);
+            ACCEPT_TOKEN(aux_sym_BANG);
         case 203:
             if (lookahead == '*')
                 ADVANCE(17);
@@ -2706,7 +2706,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '/') ||
                 (lookahead == '\\')))
                 ADVANCE(37);
-            ACCEPT_TOKEN(aux_sym_STR_SLASH);
+            ACCEPT_TOKEN(aux_sym_SLASH);
         case 204:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -2731,7 +2731,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(10);
             if (lookahead == 's')
                 ADVANCE(206);
-            ACCEPT_TOKEN(aux_sym_STR_in);
+            ACCEPT_TOKEN(aux_sym_in);
         case 206:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -2816,7 +2816,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_instanceof);
+            ACCEPT_TOKEN(aux_sym_instanceof);
         case 214:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -3118,7 +3118,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '=') ||
                 (lookahead == '\\')))
                 ADVANCE(37);
-            ACCEPT_TOKEN(aux_sym_STR_SLASH);
+            ACCEPT_TOKEN(aux_sym_SLASH);
         case 222:
             if (lookahead == '/')
                 ADVANCE(35);
@@ -3128,7 +3128,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '/') ||
                 (lookahead == '\\')))
                 ADVANCE(37);
-            ACCEPT_TOKEN(aux_sym_STR_SLASH_EQ);
+            ACCEPT_TOKEN(aux_sym_SLASH_EQ);
         case 223:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -3388,7 +3388,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_catch);
+            ACCEPT_TOKEN(aux_sym_catch);
         case 231:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -3469,7 +3469,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_finally);
+            ACCEPT_TOKEN(aux_sym_finally);
         case 238:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -3643,12 +3643,40 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(241);
             if (lookahead == '\n')
                 ADVANCE(3);
-            if (lookahead == ',')
-                ADVANCE(180);
+            if (lookahead == '!')
+                ADVANCE(123);
+            if (lookahead == '&')
+                ADVANCE(126);
+            if (lookahead == '(')
+                ADVANCE(15);
+            if (lookahead == ')')
+                ADVANCE(186);
+            if (lookahead == '*')
+                ADVANCE(128);
+            if (lookahead == '+')
+                ADVANCE(129);
+            if (lookahead == '-')
+                ADVANCE(131);
+            if (lookahead == '.')
+                ADVANCE(133);
             if (lookahead == '/')
-                ADVANCE(120);
+                ADVANCE(134);
             if (lookahead == ';')
                 ADVANCE(135);
+            if (lookahead == '<')
+                ADVANCE(136);
+            if (lookahead == '=')
+                ADVANCE(137);
+            if (lookahead == '>')
+                ADVANCE(140);
+            if (lookahead == '?')
+                ADVANCE(141);
+            if (lookahead == '[')
+                ADVANCE(41);
+            if (lookahead == 'i')
+                ADVANCE(142);
+            if (lookahead == '|')
+                ADVANCE(152);
             LEX_ERROR();
         case 242:
             START_TOKEN();
@@ -3658,6 +3686,64 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(242);
             if (lookahead == '\n')
                 ADVANCE(3);
+            if (lookahead == '!')
+                ADVANCE(123);
+            if (lookahead == '&')
+                ADVANCE(126);
+            if (lookahead == '(')
+                ADVANCE(15);
+            if (lookahead == ')')
+                ADVANCE(186);
+            if (lookahead == '*')
+                ADVANCE(155);
+            if (lookahead == '+')
+                ADVANCE(157);
+            if (lookahead == '-')
+                ADVANCE(159);
+            if (lookahead == '.')
+                ADVANCE(133);
+            if (lookahead == '/')
+                ADVANCE(161);
+            if (lookahead == ';')
+                ADVANCE(135);
+            if (lookahead == '<')
+                ADVANCE(136);
+            if (lookahead == '=')
+                ADVANCE(163);
+            if (lookahead == '>')
+                ADVANCE(140);
+            if (lookahead == '?')
+                ADVANCE(141);
+            if (lookahead == '[')
+                ADVANCE(41);
+            if (lookahead == 'i')
+                ADVANCE(142);
+            if (lookahead == '|')
+                ADVANCE(152);
+            LEX_ERROR();
+        case 243:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(243);
+            if (lookahead == '\n')
+                ADVANCE(3);
+            if (lookahead == ',')
+                ADVANCE(180);
+            if (lookahead == '/')
+                ADVANCE(120);
+            if (lookahead == ';')
+                ADVANCE(135);
+            LEX_ERROR();
+        case 244:
+            START_TOKEN();
+            if ((lookahead == '\t') ||
+                (lookahead == '\r') ||
+                (lookahead == ' '))
+                ADVANCE(244);
+            if (lookahead == '\n')
+                ADVANCE(3);
             if (lookahead == ',')
                 ADVANCE(180);
             if (lookahead == '/')
@@ -3665,24 +3751,24 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
-            if (lookahead == 'i')
-                ADVANCE(244);
-            LEX_ERROR();
-        case 243:
-            ACCEPT_TOKEN(aux_sym_STR_EQ);
-        case 244:
-            if (lookahead == 'n')
                 ADVANCE(245);
+            if (lookahead == 'i')
+                ADVANCE(246);
             LEX_ERROR();
         case 245:
-            ACCEPT_TOKEN(aux_sym_STR_in);
+            ACCEPT_TOKEN(aux_sym_EQ);
         case 246:
+            if (lookahead == 'n')
+                ADVANCE(247);
+            LEX_ERROR();
+        case 247:
+            ACCEPT_TOKEN(aux_sym_in);
+        case 248:
             START_TOKEN();
             if ((lookahead == '\t') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
-                ADVANCE(246);
+                ADVANCE(248);
             if (lookahead == '\n')
                 ADVANCE(3);
             if (lookahead == '!')
@@ -3712,13 +3798,13 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
+                ADVANCE(245);
             if (lookahead == '[')
                 ADVANCE(41);
             if (lookahead == 'f')
                 ADVANCE(170);
             if (lookahead == 'i')
-                ADVANCE(247);
+                ADVANCE(249);
             if (lookahead == 'n')
                 ADVANCE(69);
             if (lookahead == 't')
@@ -3728,7 +3814,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '{')
                 ADVANCE(118);
             LEX_ERROR();
-        case 247:
+        case 249:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
@@ -3737,22 +3823,22 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ('o' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
             if (lookahead == 'n')
-                ADVANCE(248);
+                ADVANCE(250);
             ACCEPT_TOKEN(sym_identifier);
-        case 248:
+        case 250:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
                 ('A' <= lookahead && lookahead <= 'Z') ||
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_in);
-        case 249:
+            ACCEPT_TOKEN(aux_sym_in);
+        case 251:
             START_TOKEN();
             if ((lookahead == '\t') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
-                ADVANCE(249);
+                ADVANCE(251);
             if (lookahead == '\n')
                 ADVANCE(3);
             if (lookahead == '!')
@@ -3790,12 +3876,12 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '|')
                 ADVANCE(152);
             LEX_ERROR();
-        case 250:
+        case 252:
             START_TOKEN();
             if ((lookahead == '\t') ||
                 (lookahead == '\r') ||
                 (lookahead == ' '))
-                ADVANCE(250);
+                ADVANCE(252);
             if (lookahead == '\n')
                 ADVANCE(3);
             if (lookahead == '!')
@@ -3833,66 +3919,6 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == '|')
                 ADVANCE(152);
             LEX_ERROR();
-        case 251:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(251);
-            if (lookahead == '\n')
-                ADVANCE(3);
-            if (lookahead == ',')
-                ADVANCE(180);
-            if (lookahead == '/')
-                ADVANCE(120);
-            if (lookahead == ';')
-                ADVANCE(135);
-            if (lookahead == '=')
-                ADVANCE(243);
-            LEX_ERROR();
-        case 252:
-            START_TOKEN();
-            if ((lookahead == '\t') ||
-                (lookahead == '\r') ||
-                (lookahead == ' '))
-                ADVANCE(252);
-            if (lookahead == '\n')
-                ADVANCE(3);
-            if (lookahead == '!')
-                ADVANCE(123);
-            if (lookahead == '&')
-                ADVANCE(126);
-            if (lookahead == '(')
-                ADVANCE(15);
-            if (lookahead == ')')
-                ADVANCE(186);
-            if (lookahead == '*')
-                ADVANCE(128);
-            if (lookahead == '+')
-                ADVANCE(129);
-            if (lookahead == '-')
-                ADVANCE(131);
-            if (lookahead == '.')
-                ADVANCE(133);
-            if (lookahead == '/')
-                ADVANCE(134);
-            if (lookahead == ';')
-                ADVANCE(135);
-            if (lookahead == '<')
-                ADVANCE(136);
-            if (lookahead == '=')
-                ADVANCE(137);
-            if (lookahead == '>')
-                ADVANCE(140);
-            if (lookahead == '?')
-                ADVANCE(141);
-            if (lookahead == '[')
-                ADVANCE(41);
-            if (lookahead == 'i')
-                ADVANCE(142);
-            if (lookahead == '|')
-                ADVANCE(152);
-            LEX_ERROR();
         case 253:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -3901,40 +3927,14 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(253);
             if (lookahead == '\n')
                 ADVANCE(3);
-            if (lookahead == '!')
-                ADVANCE(123);
-            if (lookahead == '&')
-                ADVANCE(126);
-            if (lookahead == '(')
-                ADVANCE(15);
-            if (lookahead == ')')
-                ADVANCE(186);
-            if (lookahead == '*')
-                ADVANCE(155);
-            if (lookahead == '+')
-                ADVANCE(157);
-            if (lookahead == '-')
-                ADVANCE(159);
-            if (lookahead == '.')
-                ADVANCE(133);
+            if (lookahead == ',')
+                ADVANCE(180);
             if (lookahead == '/')
-                ADVANCE(161);
+                ADVANCE(120);
             if (lookahead == ';')
                 ADVANCE(135);
-            if (lookahead == '<')
-                ADVANCE(136);
             if (lookahead == '=')
-                ADVANCE(163);
-            if (lookahead == '>')
-                ADVANCE(140);
-            if (lookahead == '?')
-                ADVANCE(141);
-            if (lookahead == '[')
-                ADVANCE(41);
-            if (lookahead == 'i')
-                ADVANCE(142);
-            if (lookahead == '|')
-                ADVANCE(152);
+                ADVANCE(245);
             LEX_ERROR();
         case 254:
             START_TOKEN();
@@ -3966,7 +3966,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(258);
             LEX_ERROR();
         case 258:
-            ACCEPT_TOKEN(aux_sym_STR_case);
+            ACCEPT_TOKEN(aux_sym_case);
         case 259:
             if (lookahead == 'e')
                 ADVANCE(260);
@@ -3992,7 +3992,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(265);
             LEX_ERROR();
         case 265:
-            ACCEPT_TOKEN(aux_sym_STR_default);
+            ACCEPT_TOKEN(aux_sym_default);
         case 266:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -4094,7 +4094,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_case);
+            ACCEPT_TOKEN(aux_sym_case);
         case 271:
             if ((lookahead == '$') ||
                 ('0' <= lookahead && lookahead <= '9') ||
@@ -4170,7 +4170,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_default);
+            ACCEPT_TOKEN(aux_sym_default);
         case 278:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -4653,7 +4653,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 (lookahead == '_') ||
                 ('a' <= lookahead && lookahead <= 'z'))
                 ADVANCE(10);
-            ACCEPT_TOKEN(aux_sym_STR_else);
+            ACCEPT_TOKEN(aux_sym_else);
         case 290:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -5153,7 +5153,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
+                ADVANCE(245);
             if (lookahead == '[')
                 ADVANCE(41);
             if (lookahead == 'b')
@@ -5223,7 +5223,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
+                ADVANCE(245);
             if (lookahead == '[')
                 ADVANCE(41);
             if (lookahead == 'b')
@@ -5710,7 +5710,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
+                ADVANCE(245);
             if (lookahead == '[')
                 ADVANCE(41);
             if (lookahead == 'b')
@@ -5779,7 +5779,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
+                ADVANCE(245);
             if (lookahead == '[')
                 ADVANCE(41);
             if (lookahead == 'b')
@@ -6618,7 +6618,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
+                ADVANCE(245);
             if (lookahead == '[')
                 ADVANCE(41);
             if (lookahead == 'b')
@@ -6687,7 +6687,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
             if (lookahead == ';')
                 ADVANCE(135);
             if (lookahead == '=')
-                ADVANCE(243);
+                ADVANCE(245);
             if (lookahead == '[')
                 ADVANCE(41);
             if (lookahead == 'b')
@@ -6918,1350 +6918,1350 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [4] = 122,
     [5] = 122,
     [6] = 154,
-    [7] = 164,
-    [8] = 154,
-    [9] = 119,
-    [10] = 165,
-    [11] = 166,
+    [7] = 119,
+    [8] = 164,
+    [9] = 165,
+    [10] = 166,
+    [11] = 168,
     [12] = 168,
     [13] = 168,
-    [14] = 168,
-    [15] = 169,
-    [16] = 168,
-    [17] = 173,
-    [18] = 174,
-    [19] = 169,
-    [20] = 164,
-    [21] = 169,
-    [22] = 175,
-    [23] = 177,
+    [14] = 169,
+    [15] = 168,
+    [16] = 173,
+    [17] = 174,
+    [18] = 169,
+    [19] = 164,
+    [20] = 169,
+    [21] = 175,
+    [22] = 177,
+    [23] = 169,
     [24] = 169,
     [25] = 169,
-    [26] = 169,
-    [27] = 122,
-    [28] = 178,
-    [29] = 179,
-    [30] = 181,
-    [31] = 122,
-    [32] = 169,
-    [33] = 183,
-    [34] = 183,
-    [35] = 184,
-    [36] = 184,
-    [37] = 178,
-    [38] = 169,
-    [39] = 175,
-    [40] = 177,
-    [41] = 169,
-    [42] = 169,
+    [26] = 154,
+    [27] = 169,
+    [28] = 169,
+    [29] = 169,
+    [30] = 122,
+    [31] = 178,
+    [32] = 179,
+    [33] = 122,
+    [34] = 181,
+    [35] = 169,
+    [36] = 183,
+    [37] = 183,
+    [38] = 184,
+    [39] = 178,
+    [40] = 169,
+    [41] = 175,
+    [42] = 177,
     [43] = 169,
-    [44] = 183,
-    [45] = 183,
-    [46] = 185,
+    [44] = 169,
+    [45] = 169,
+    [46] = 184,
     [47] = 169,
-    [48] = 165,
-    [49] = 183,
-    [50] = 184,
-    [51] = 187,
-    [52] = 187,
-    [53] = 188,
-    [54] = 189,
-    [55] = 188,
-    [56] = 178,
+    [48] = 169,
+    [49] = 169,
+    [50] = 183,
+    [51] = 183,
+    [52] = 185,
+    [53] = 169,
+    [54] = 165,
+    [55] = 169,
+    [56] = 169,
     [57] = 169,
-    [58] = 175,
-    [59] = 177,
+    [58] = 183,
+    [59] = 169,
     [60] = 169,
     [61] = 169,
-    [62] = 169,
-    [63] = 187,
-    [64] = 187,
-    [65] = 185,
-    [66] = 169,
-    [67] = 165,
+    [62] = 183,
+    [63] = 183,
+    [64] = 183,
+    [65] = 183,
+    [66] = 183,
+    [67] = 187,
     [68] = 187,
     [69] = 188,
-    [70] = 187,
-    [71] = 189,
-    [72] = 188,
-    [73] = 169,
+    [70] = 178,
+    [71] = 169,
+    [72] = 175,
+    [73] = 177,
     [74] = 169,
     [75] = 169,
     [76] = 169,
-    [77] = 169,
+    [77] = 188,
     [78] = 169,
     [79] = 169,
-    [80] = 187,
+    [80] = 169,
     [81] = 187,
     [82] = 187,
-    [83] = 187,
-    [84] = 187,
-    [85] = 190,
-    [86] = 190,
-    [87] = 191,
-    [88] = 191,
-    [89] = 178,
+    [83] = 185,
+    [84] = 169,
+    [85] = 165,
+    [86] = 169,
+    [87] = 169,
+    [88] = 169,
+    [89] = 187,
     [90] = 169,
-    [91] = 175,
-    [92] = 177,
-    [93] = 169,
-    [94] = 169,
-    [95] = 169,
-    [96] = 190,
-    [97] = 190,
-    [98] = 185,
+    [91] = 169,
+    [92] = 169,
+    [93] = 187,
+    [94] = 187,
+    [95] = 187,
+    [96] = 187,
+    [97] = 187,
+    [98] = 187,
     [99] = 169,
-    [100] = 165,
-    [101] = 190,
-    [102] = 191,
-    [103] = 187,
-    [104] = 189,
+    [100] = 187,
+    [101] = 188,
+    [102] = 189,
+    [103] = 189,
+    [104] = 190,
     [105] = 191,
-    [106] = 192,
-    [107] = 192,
-    [108] = 193,
-    [109] = 194,
-    [110] = 193,
-    [111] = 178,
+    [106] = 178,
+    [107] = 169,
+    [108] = 175,
+    [109] = 177,
+    [110] = 169,
+    [111] = 169,
     [112] = 169,
     [113] = 190,
-    [114] = 175,
-    [115] = 177,
+    [114] = 169,
+    [115] = 169,
     [116] = 169,
-    [117] = 169,
-    [118] = 169,
-    [119] = 192,
-    [120] = 192,
-    [121] = 185,
+    [117] = 189,
+    [118] = 189,
+    [119] = 185,
+    [120] = 169,
+    [121] = 165,
     [122] = 169,
-    [123] = 165,
-    [124] = 192,
-    [125] = 193,
-    [126] = 187,
-    [127] = 189,
-    [128] = 193,
-    [129] = 192,
-    [130] = 194,
-    [131] = 192,
-    [132] = 195,
-    [133] = 169,
-    [134] = 192,
-    [135] = 192,
-    [136] = 194,
-    [137] = 195,
-    [138] = 169,
-    [139] = 169,
-    [140] = 169,
-    [141] = 169,
-    [142] = 169,
-    [143] = 169,
-    [144] = 169,
-    [145] = 192,
-    [146] = 192,
-    [147] = 192,
-    [148] = 192,
-    [149] = 192,
-    [150] = 190,
+    [123] = 169,
+    [124] = 169,
+    [125] = 189,
+    [126] = 169,
+    [127] = 169,
+    [128] = 169,
+    [129] = 189,
+    [130] = 189,
+    [131] = 189,
+    [132] = 189,
+    [133] = 189,
+    [134] = 187,
+    [135] = 169,
+    [136] = 189,
+    [137] = 190,
+    [138] = 189,
+    [139] = 191,
+    [140] = 190,
+    [141] = 192,
+    [142] = 192,
+    [143] = 193,
+    [144] = 194,
+    [145] = 178,
+    [146] = 169,
+    [147] = 189,
+    [148] = 175,
+    [149] = 177,
+    [150] = 169,
     [151] = 169,
     [152] = 169,
-    [153] = 169,
+    [153] = 193,
     [154] = 169,
     [155] = 169,
     [156] = 169,
-    [157] = 169,
-    [158] = 169,
-    [159] = 190,
-    [160] = 190,
-    [161] = 190,
-    [162] = 190,
-    [163] = 190,
-    [164] = 190,
-    [165] = 169,
-    [166] = 190,
-    [167] = 192,
-    [168] = 190,
+    [157] = 192,
+    [158] = 192,
+    [159] = 185,
+    [160] = 169,
+    [161] = 165,
+    [162] = 169,
+    [163] = 169,
+    [164] = 169,
+    [165] = 192,
+    [166] = 169,
+    [167] = 169,
+    [168] = 169,
     [169] = 192,
     [170] = 192,
     [171] = 192,
     [172] = 192,
     [173] = 192,
-    [174] = 168,
-    [175] = 196,
-    [176] = 195,
-    [177] = 194,
-    [178] = 173,
-    [179] = 192,
-    [180] = 166,
-    [181] = 166,
-    [182] = 166,
-    [183] = 122,
-    [184] = 197,
-    [185] = 198,
-    [186] = 165,
-    [187] = 166,
-    [188] = 192,
-    [189] = 168,
-    [190] = 168,
-    [191] = 168,
-    [192] = 168,
-    [193] = 173,
-    [194] = 174,
-    [195] = 169,
-    [196] = 164,
-    [197] = 169,
-    [198] = 199,
-    [199] = 199,
-    [200] = 154,
-    [201] = 200,
-    [202] = 178,
-    [203] = 169,
-    [204] = 175,
-    [205] = 177,
-    [206] = 169,
-    [207] = 169,
-    [208] = 169,
-    [209] = 199,
-    [210] = 200,
-    [211] = 169,
-    [212] = 169,
-    [213] = 199,
-    [214] = 199,
-    [215] = 185,
-    [216] = 169,
-    [217] = 169,
-    [218] = 165,
-    [219] = 169,
-    [220] = 169,
-    [221] = 169,
-    [222] = 199,
+    [174] = 187,
+    [175] = 169,
+    [176] = 192,
+    [177] = 193,
+    [178] = 189,
+    [179] = 191,
+    [180] = 193,
+    [181] = 192,
+    [182] = 194,
+    [183] = 192,
+    [184] = 195,
+    [185] = 169,
+    [186] = 192,
+    [187] = 192,
+    [188] = 194,
+    [189] = 195,
+    [190] = 192,
+    [191] = 192,
+    [192] = 192,
+    [193] = 192,
+    [194] = 192,
+    [195] = 192,
+    [196] = 192,
+    [197] = 196,
+    [198] = 168,
+    [199] = 196,
+    [200] = 195,
+    [201] = 173,
+    [202] = 194,
+    [203] = 195,
+    [204] = 165,
+    [205] = 194,
+    [206] = 195,
+    [207] = 192,
+    [208] = 166,
+    [209] = 166,
+    [210] = 166,
+    [211] = 122,
+    [212] = 197,
+    [213] = 198,
+    [214] = 165,
+    [215] = 166,
+    [216] = 192,
+    [217] = 168,
+    [218] = 168,
+    [219] = 168,
+    [220] = 168,
+    [221] = 173,
+    [222] = 174,
     [223] = 169,
-    [224] = 169,
+    [224] = 164,
     [225] = 169,
     [226] = 199,
     [227] = 199,
-    [228] = 199,
-    [229] = 199,
-    [230] = 199,
-    [231] = 190,
-    [232] = 169,
-    [233] = 199,
-    [234] = 200,
-    [235] = 187,
-    [236] = 189,
-    [237] = 200,
-    [238] = 199,
-    [239] = 192,
-    [240] = 194,
-    [241] = 199,
-    [242] = 195,
-    [243] = 199,
-    [244] = 199,
-    [245] = 199,
-    [246] = 199,
-    [247] = 199,
-    [248] = 199,
-    [249] = 168,
-    [250] = 196,
-    [251] = 195,
-    [252] = 173,
+    [228] = 154,
+    [229] = 178,
+    [230] = 169,
+    [231] = 175,
+    [232] = 177,
+    [233] = 169,
+    [234] = 169,
+    [235] = 169,
+    [236] = 200,
+    [237] = 169,
+    [238] = 169,
+    [239] = 169,
+    [240] = 199,
+    [241] = 200,
+    [242] = 199,
+    [243] = 185,
+    [244] = 169,
+    [245] = 165,
+    [246] = 169,
+    [247] = 169,
+    [248] = 169,
+    [249] = 199,
+    [250] = 169,
+    [251] = 169,
+    [252] = 169,
     [253] = 199,
-    [254] = 166,
-    [255] = 197,
-    [256] = 198,
+    [254] = 199,
+    [255] = 199,
+    [256] = 199,
     [257] = 199,
-    [258] = 199,
-    [259] = 201,
-    [260] = 173,
-    [261] = 199,
-    [262] = 196,
-    [263] = 195,
-    [264] = 173,
-    [265] = 199,
-    [266] = 214,
-    [267] = 214,
-    [268] = 215,
-    [269] = 216,
-    [270] = 215,
-    [271] = 178,
-    [272] = 169,
-    [273] = 175,
+    [258] = 187,
+    [259] = 169,
+    [260] = 199,
+    [261] = 200,
+    [262] = 189,
+    [263] = 191,
+    [264] = 200,
+    [265] = 192,
+    [266] = 194,
+    [267] = 199,
+    [268] = 195,
+    [269] = 199,
+    [270] = 199,
+    [271] = 199,
+    [272] = 199,
+    [273] = 199,
     [274] = 199,
-    [275] = 177,
-    [276] = 169,
-    [277] = 169,
-    [278] = 169,
-    [279] = 214,
-    [280] = 214,
-    [281] = 185,
-    [282] = 169,
-    [283] = 165,
-    [284] = 214,
-    [285] = 215,
-    [286] = 187,
-    [287] = 189,
-    [288] = 215,
-    [289] = 192,
-    [290] = 194,
-    [291] = 214,
-    [292] = 195,
-    [293] = 214,
+    [275] = 199,
+    [276] = 199,
+    [277] = 196,
+    [278] = 168,
+    [279] = 196,
+    [280] = 195,
+    [281] = 173,
+    [282] = 199,
+    [283] = 166,
+    [284] = 197,
+    [285] = 198,
+    [286] = 199,
+    [287] = 201,
+    [288] = 199,
+    [289] = 173,
+    [290] = 199,
+    [291] = 195,
+    [292] = 173,
+    [293] = 199,
     [294] = 214,
     [295] = 214,
-    [296] = 214,
-    [297] = 214,
-    [298] = 168,
-    [299] = 196,
-    [300] = 195,
-    [301] = 173,
-    [302] = 214,
-    [303] = 166,
-    [304] = 197,
-    [305] = 198,
-    [306] = 214,
-    [307] = 214,
-    [308] = 173,
-    [309] = 214,
-    [310] = 196,
-    [311] = 195,
-    [312] = 173,
-    [313] = 214,
-    [314] = 214,
-    [315] = 216,
-    [316] = 214,
-    [317] = 189,
-    [318] = 169,
-    [319] = 214,
-    [320] = 214,
-    [321] = 216,
-    [322] = 189,
-    [323] = 169,
-    [324] = 169,
-    [325] = 169,
-    [326] = 169,
-    [327] = 169,
+    [296] = 215,
+    [297] = 216,
+    [298] = 178,
+    [299] = 169,
+    [300] = 175,
+    [301] = 199,
+    [302] = 177,
+    [303] = 169,
+    [304] = 169,
+    [305] = 169,
+    [306] = 215,
+    [307] = 169,
+    [308] = 169,
+    [309] = 169,
+    [310] = 214,
+    [311] = 214,
+    [312] = 185,
+    [313] = 169,
+    [314] = 165,
+    [315] = 169,
+    [316] = 169,
+    [317] = 169,
+    [318] = 214,
+    [319] = 169,
+    [320] = 169,
+    [321] = 169,
+    [322] = 214,
+    [323] = 214,
+    [324] = 214,
+    [325] = 214,
+    [326] = 214,
+    [327] = 187,
     [328] = 169,
-    [329] = 169,
-    [330] = 214,
-    [331] = 214,
-    [332] = 214,
-    [333] = 214,
-    [334] = 214,
-    [335] = 190,
-    [336] = 169,
-    [337] = 214,
+    [329] = 214,
+    [330] = 215,
+    [331] = 189,
+    [332] = 191,
+    [333] = 215,
+    [334] = 192,
+    [335] = 194,
+    [336] = 214,
+    [337] = 195,
     [338] = 214,
     [339] = 214,
-    [340] = 217,
-    [341] = 217,
-    [342] = 218,
-    [343] = 195,
-    [344] = 218,
-    [345] = 178,
-    [346] = 169,
-    [347] = 175,
-    [348] = 177,
-    [349] = 169,
-    [350] = 169,
-    [351] = 169,
-    [352] = 217,
-    [353] = 217,
-    [354] = 185,
-    [355] = 169,
-    [356] = 165,
-    [357] = 217,
-    [358] = 218,
-    [359] = 187,
-    [360] = 189,
-    [361] = 218,
-    [362] = 192,
-    [363] = 194,
-    [364] = 217,
-    [365] = 195,
-    [366] = 217,
-    [367] = 217,
-    [368] = 217,
-    [369] = 217,
-    [370] = 217,
-    [371] = 168,
-    [372] = 196,
-    [373] = 195,
-    [374] = 173,
-    [375] = 217,
-    [376] = 166,
-    [377] = 197,
-    [378] = 198,
-    [379] = 217,
-    [380] = 217,
-    [381] = 173,
-    [382] = 217,
-    [383] = 196,
-    [384] = 195,
-    [385] = 173,
-    [386] = 217,
-    [387] = 214,
-    [388] = 216,
-    [389] = 217,
-    [390] = 189,
-    [391] = 217,
-    [392] = 217,
-    [393] = 217,
-    [394] = 195,
+    [340] = 214,
+    [341] = 214,
+    [342] = 214,
+    [343] = 214,
+    [344] = 214,
+    [345] = 214,
+    [346] = 196,
+    [347] = 168,
+    [348] = 196,
+    [349] = 195,
+    [350] = 173,
+    [351] = 214,
+    [352] = 166,
+    [353] = 197,
+    [354] = 198,
+    [355] = 214,
+    [356] = 214,
+    [357] = 173,
+    [358] = 214,
+    [359] = 195,
+    [360] = 173,
+    [361] = 214,
+    [362] = 214,
+    [363] = 216,
+    [364] = 214,
+    [365] = 191,
+    [366] = 169,
+    [367] = 214,
+    [368] = 214,
+    [369] = 216,
+    [370] = 191,
+    [371] = 214,
+    [372] = 217,
+    [373] = 217,
+    [374] = 218,
+    [375] = 195,
+    [376] = 178,
+    [377] = 169,
+    [378] = 175,
+    [379] = 177,
+    [380] = 169,
+    [381] = 169,
+    [382] = 169,
+    [383] = 218,
+    [384] = 169,
+    [385] = 169,
+    [386] = 169,
+    [387] = 217,
+    [388] = 217,
+    [389] = 185,
+    [390] = 169,
+    [391] = 165,
+    [392] = 169,
+    [393] = 169,
+    [394] = 169,
     [395] = 217,
     [396] = 169,
     [397] = 169,
     [398] = 169,
-    [399] = 169,
-    [400] = 169,
-    [401] = 169,
-    [402] = 169,
+    [399] = 217,
+    [400] = 217,
+    [401] = 217,
+    [402] = 217,
     [403] = 217,
-    [404] = 217,
-    [405] = 217,
+    [404] = 187,
+    [405] = 169,
     [406] = 217,
-    [407] = 217,
-    [408] = 190,
-    [409] = 169,
-    [410] = 217,
-    [411] = 217,
-    [412] = 179,
+    [407] = 218,
+    [408] = 189,
+    [409] = 191,
+    [410] = 218,
+    [411] = 192,
+    [412] = 194,
     [413] = 217,
-    [414] = 198,
-    [415] = 219,
+    [414] = 195,
+    [415] = 217,
     [416] = 217,
-    [417] = 179,
-    [418] = 198,
+    [417] = 217,
+    [418] = 217,
     [419] = 217,
-    [420] = 169,
-    [421] = 169,
+    [420] = 217,
+    [421] = 217,
     [422] = 217,
-    [423] = 217,
-    [424] = 214,
-    [425] = 179,
-    [426] = 214,
-    [427] = 198,
-    [428] = 214,
-    [429] = 214,
-    [430] = 169,
-    [431] = 169,
-    [432] = 214,
-    [433] = 214,
-    [434] = 189,
-    [435] = 199,
-    [436] = 199,
-    [437] = 217,
-    [438] = 195,
-    [439] = 199,
-    [440] = 179,
-    [441] = 199,
-    [442] = 198,
-    [443] = 199,
-    [444] = 199,
-    [445] = 220,
-    [446] = 169,
-    [447] = 165,
-    [448] = 154,
-    [449] = 187,
-    [450] = 189,
-    [451] = 154,
-    [452] = 223,
-    [453] = 122,
-    [454] = 122,
-    [455] = 224,
-    [456] = 185,
-    [457] = 169,
-    [458] = 169,
-    [459] = 169,
-    [460] = 169,
-    [461] = 122,
-    [462] = 169,
-    [463] = 169,
-    [464] = 169,
-    [465] = 122,
-    [466] = 122,
-    [467] = 122,
-    [468] = 122,
-    [469] = 122,
-    [470] = 190,
-    [471] = 169,
-    [472] = 122,
-    [473] = 122,
-    [474] = 192,
-    [475] = 194,
-    [476] = 122,
-    [477] = 195,
-    [478] = 122,
-    [479] = 122,
-    [480] = 122,
-    [481] = 223,
-    [482] = 224,
-    [483] = 225,
-    [484] = 166,
-    [485] = 197,
-    [486] = 198,
-    [487] = 225,
-    [488] = 225,
-    [489] = 238,
-    [490] = 166,
-    [491] = 168,
-    [492] = 173,
-    [493] = 166,
-    [494] = 166,
-    [495] = 197,
-    [496] = 198,
-    [497] = 166,
-    [498] = 166,
-    [499] = 165,
-    [500] = 195,
-    [501] = 173,
-    [502] = 238,
-    [503] = 166,
-    [504] = 197,
-    [505] = 198,
-    [506] = 238,
-    [507] = 238,
-    [508] = 166,
-    [509] = 239,
-    [510] = 169,
-    [511] = 217,
-    [512] = 195,
-    [513] = 239,
-    [514] = 166,
-    [515] = 164,
-    [516] = 240,
-    [517] = 174,
-    [518] = 122,
-    [519] = 122,
-    [520] = 154,
-    [521] = 154,
-    [522] = 165,
-    [523] = 178,
-    [524] = 169,
-    [525] = 175,
-    [526] = 177,
-    [527] = 169,
-    [528] = 169,
-    [529] = 169,
-    [530] = 122,
-    [531] = 154,
-    [532] = 169,
-    [533] = 169,
-    [534] = 169,
-    [535] = 122,
-    [536] = 122,
-    [537] = 185,
-    [538] = 169,
-    [539] = 165,
-    [540] = 169,
-    [541] = 169,
-    [542] = 169,
-    [543] = 122,
-    [544] = 169,
-    [545] = 169,
-    [546] = 169,
-    [547] = 122,
-    [548] = 122,
-    [549] = 122,
-    [550] = 122,
-    [551] = 122,
-    [552] = 190,
+    [423] = 196,
+    [424] = 168,
+    [425] = 196,
+    [426] = 195,
+    [427] = 173,
+    [428] = 217,
+    [429] = 166,
+    [430] = 197,
+    [431] = 198,
+    [432] = 217,
+    [433] = 217,
+    [434] = 173,
+    [435] = 217,
+    [436] = 195,
+    [437] = 173,
+    [438] = 217,
+    [439] = 214,
+    [440] = 216,
+    [441] = 217,
+    [442] = 191,
+    [443] = 217,
+    [444] = 217,
+    [445] = 217,
+    [446] = 195,
+    [447] = 217,
+    [448] = 179,
+    [449] = 217,
+    [450] = 197,
+    [451] = 219,
+    [452] = 217,
+    [453] = 179,
+    [454] = 197,
+    [455] = 217,
+    [456] = 214,
+    [457] = 179,
+    [458] = 214,
+    [459] = 197,
+    [460] = 214,
+    [461] = 214,
+    [462] = 191,
+    [463] = 199,
+    [464] = 199,
+    [465] = 217,
+    [466] = 195,
+    [467] = 199,
+    [468] = 179,
+    [469] = 199,
+    [470] = 197,
+    [471] = 199,
+    [472] = 199,
+    [473] = 220,
+    [474] = 169,
+    [475] = 165,
+    [476] = 154,
+    [477] = 189,
+    [478] = 191,
+    [479] = 154,
+    [480] = 223,
+    [481] = 122,
+    [482] = 122,
+    [483] = 224,
+    [484] = 185,
+    [485] = 169,
+    [486] = 169,
+    [487] = 169,
+    [488] = 122,
+    [489] = 169,
+    [490] = 169,
+    [491] = 169,
+    [492] = 122,
+    [493] = 122,
+    [494] = 122,
+    [495] = 122,
+    [496] = 122,
+    [497] = 187,
+    [498] = 169,
+    [499] = 122,
+    [500] = 192,
+    [501] = 194,
+    [502] = 122,
+    [503] = 195,
+    [504] = 122,
+    [505] = 122,
+    [506] = 122,
+    [507] = 223,
+    [508] = 224,
+    [509] = 225,
+    [510] = 166,
+    [511] = 197,
+    [512] = 198,
+    [513] = 225,
+    [514] = 225,
+    [515] = 238,
+    [516] = 166,
+    [517] = 168,
+    [518] = 173,
+    [519] = 166,
+    [520] = 166,
+    [521] = 197,
+    [522] = 198,
+    [523] = 166,
+    [524] = 166,
+    [525] = 165,
+    [526] = 195,
+    [527] = 173,
+    [528] = 238,
+    [529] = 166,
+    [530] = 197,
+    [531] = 198,
+    [532] = 238,
+    [533] = 238,
+    [534] = 166,
+    [535] = 239,
+    [536] = 169,
+    [537] = 217,
+    [538] = 195,
+    [539] = 239,
+    [540] = 166,
+    [541] = 164,
+    [542] = 240,
+    [543] = 174,
+    [544] = 122,
+    [545] = 122,
+    [546] = 154,
+    [547] = 165,
+    [548] = 178,
+    [549] = 169,
+    [550] = 175,
+    [551] = 177,
+    [552] = 169,
     [553] = 169,
-    [554] = 122,
+    [554] = 169,
     [555] = 154,
-    [556] = 187,
-    [557] = 189,
-    [558] = 154,
-    [559] = 192,
-    [560] = 194,
-    [561] = 122,
-    [562] = 195,
+    [556] = 169,
+    [557] = 169,
+    [558] = 169,
+    [559] = 122,
+    [560] = 154,
+    [561] = 169,
+    [562] = 122,
     [563] = 122,
-    [564] = 122,
-    [565] = 122,
-    [566] = 122,
+    [564] = 185,
+    [565] = 169,
+    [566] = 165,
     [567] = 122,
-    [568] = 122,
-    [569] = 122,
-    [570] = 168,
-    [571] = 196,
-    [572] = 195,
-    [573] = 173,
-    [574] = 122,
-    [575] = 166,
-    [576] = 197,
-    [577] = 198,
+    [568] = 169,
+    [569] = 169,
+    [570] = 122,
+    [571] = 122,
+    [572] = 154,
+    [573] = 189,
+    [574] = 191,
+    [575] = 154,
+    [576] = 192,
+    [577] = 194,
     [578] = 122,
-    [579] = 122,
-    [580] = 173,
+    [579] = 195,
+    [580] = 122,
     [581] = 122,
-    [582] = 196,
-    [583] = 195,
-    [584] = 173,
-    [585] = 122,
-    [586] = 214,
-    [587] = 216,
+    [582] = 169,
+    [583] = 169,
+    [584] = 169,
+    [585] = 169,
+    [586] = 122,
+    [587] = 122,
     [588] = 122,
-    [589] = 189,
-    [590] = 122,
+    [589] = 187,
+    [590] = 169,
     [591] = 122,
-    [592] = 217,
-    [593] = 195,
-    [594] = 122,
-    [595] = 179,
-    [596] = 122,
-    [597] = 198,
-    [598] = 122,
-    [599] = 122,
-    [600] = 241,
-    [601] = 242,
-    [602] = 246,
-    [603] = 164,
-    [604] = 165,
+    [592] = 122,
+    [593] = 241,
+    [594] = 241,
+    [595] = 242,
+    [596] = 178,
+    [597] = 169,
+    [598] = 175,
+    [599] = 177,
+    [600] = 169,
+    [601] = 169,
+    [602] = 169,
+    [603] = 242,
+    [604] = 169,
     [605] = 169,
     [606] = 169,
-    [607] = 249,
-    [608] = 249,
-    [609] = 250,
-    [610] = 250,
-    [611] = 178,
+    [607] = 241,
+    [608] = 241,
+    [609] = 185,
+    [610] = 169,
+    [611] = 165,
     [612] = 169,
-    [613] = 175,
-    [614] = 177,
-    [615] = 169,
+    [613] = 169,
+    [614] = 169,
+    [615] = 241,
     [616] = 169,
     [617] = 169,
-    [618] = 249,
-    [619] = 249,
-    [620] = 185,
-    [621] = 169,
-    [622] = 165,
-    [623] = 249,
-    [624] = 250,
-    [625] = 187,
-    [626] = 189,
-    [627] = 250,
-    [628] = 192,
-    [629] = 194,
-    [630] = 249,
-    [631] = 195,
-    [632] = 249,
-    [633] = 249,
-    [634] = 249,
-    [635] = 249,
-    [636] = 249,
-    [637] = 168,
-    [638] = 196,
-    [639] = 195,
-    [640] = 173,
-    [641] = 249,
-    [642] = 166,
-    [643] = 197,
-    [644] = 198,
-    [645] = 249,
-    [646] = 249,
+    [618] = 169,
+    [619] = 241,
+    [620] = 241,
+    [621] = 241,
+    [622] = 241,
+    [623] = 241,
+    [624] = 187,
+    [625] = 169,
+    [626] = 241,
+    [627] = 242,
+    [628] = 189,
+    [629] = 191,
+    [630] = 242,
+    [631] = 192,
+    [632] = 194,
+    [633] = 241,
+    [634] = 195,
+    [635] = 241,
+    [636] = 241,
+    [637] = 241,
+    [638] = 241,
+    [639] = 241,
+    [640] = 241,
+    [641] = 241,
+    [642] = 241,
+    [643] = 196,
+    [644] = 168,
+    [645] = 196,
+    [646] = 195,
     [647] = 173,
-    [648] = 249,
-    [649] = 196,
-    [650] = 195,
-    [651] = 173,
-    [652] = 249,
-    [653] = 214,
-    [654] = 216,
-    [655] = 249,
-    [656] = 189,
-    [657] = 249,
-    [658] = 249,
-    [659] = 217,
-    [660] = 195,
-    [661] = 249,
-    [662] = 179,
-    [663] = 249,
-    [664] = 198,
-    [665] = 249,
-    [666] = 249,
-    [667] = 169,
-    [668] = 169,
-    [669] = 169,
-    [670] = 249,
-    [671] = 169,
-    [672] = 169,
-    [673] = 169,
-    [674] = 169,
-    [675] = 169,
-    [676] = 169,
-    [677] = 249,
-    [678] = 249,
-    [679] = 249,
-    [680] = 249,
-    [681] = 249,
-    [682] = 190,
-    [683] = 169,
-    [684] = 249,
-    [685] = 249,
-    [686] = 249,
-    [687] = 217,
-    [688] = 239,
-    [689] = 166,
-    [690] = 241,
-    [691] = 251,
-    [692] = 164,
-    [693] = 174,
-    [694] = 169,
-    [695] = 252,
-    [696] = 252,
-    [697] = 253,
-    [698] = 253,
-    [699] = 178,
-    [700] = 169,
-    [701] = 175,
-    [702] = 177,
-    [703] = 169,
-    [704] = 169,
-    [705] = 169,
-    [706] = 252,
-    [707] = 252,
-    [708] = 185,
-    [709] = 169,
-    [710] = 165,
-    [711] = 252,
-    [712] = 253,
-    [713] = 187,
-    [714] = 189,
-    [715] = 253,
-    [716] = 192,
-    [717] = 194,
+    [648] = 241,
+    [649] = 166,
+    [650] = 197,
+    [651] = 198,
+    [652] = 241,
+    [653] = 241,
+    [654] = 173,
+    [655] = 241,
+    [656] = 195,
+    [657] = 173,
+    [658] = 241,
+    [659] = 214,
+    [660] = 216,
+    [661] = 241,
+    [662] = 191,
+    [663] = 241,
+    [664] = 241,
+    [665] = 217,
+    [666] = 195,
+    [667] = 241,
+    [668] = 179,
+    [669] = 241,
+    [670] = 197,
+    [671] = 241,
+    [672] = 241,
+    [673] = 239,
+    [674] = 166,
+    [675] = 122,
+    [676] = 122,
+    [677] = 122,
+    [678] = 122,
+    [679] = 196,
+    [680] = 168,
+    [681] = 196,
+    [682] = 195,
+    [683] = 173,
+    [684] = 122,
+    [685] = 166,
+    [686] = 197,
+    [687] = 198,
+    [688] = 122,
+    [689] = 122,
+    [690] = 173,
+    [691] = 122,
+    [692] = 195,
+    [693] = 173,
+    [694] = 122,
+    [695] = 214,
+    [696] = 216,
+    [697] = 122,
+    [698] = 191,
+    [699] = 122,
+    [700] = 122,
+    [701] = 217,
+    [702] = 195,
+    [703] = 122,
+    [704] = 179,
+    [705] = 122,
+    [706] = 197,
+    [707] = 122,
+    [708] = 122,
+    [709] = 243,
+    [710] = 244,
+    [711] = 164,
+    [712] = 248,
+    [713] = 165,
+    [714] = 169,
+    [715] = 169,
+    [716] = 251,
+    [717] = 251,
     [718] = 252,
-    [719] = 195,
-    [720] = 252,
-    [721] = 252,
-    [722] = 252,
-    [723] = 252,
-    [724] = 252,
-    [725] = 168,
-    [726] = 196,
-    [727] = 195,
-    [728] = 173,
-    [729] = 252,
-    [730] = 166,
-    [731] = 197,
-    [732] = 198,
-    [733] = 252,
-    [734] = 252,
-    [735] = 173,
-    [736] = 252,
-    [737] = 196,
-    [738] = 195,
-    [739] = 173,
-    [740] = 252,
-    [741] = 214,
-    [742] = 216,
-    [743] = 252,
-    [744] = 189,
-    [745] = 252,
-    [746] = 252,
-    [747] = 217,
-    [748] = 195,
-    [749] = 252,
-    [750] = 179,
-    [751] = 252,
-    [752] = 198,
+    [719] = 178,
+    [720] = 169,
+    [721] = 175,
+    [722] = 177,
+    [723] = 169,
+    [724] = 169,
+    [725] = 169,
+    [726] = 252,
+    [727] = 169,
+    [728] = 169,
+    [729] = 169,
+    [730] = 251,
+    [731] = 251,
+    [732] = 185,
+    [733] = 169,
+    [734] = 165,
+    [735] = 169,
+    [736] = 169,
+    [737] = 169,
+    [738] = 251,
+    [739] = 169,
+    [740] = 169,
+    [741] = 169,
+    [742] = 251,
+    [743] = 251,
+    [744] = 251,
+    [745] = 251,
+    [746] = 251,
+    [747] = 187,
+    [748] = 169,
+    [749] = 251,
+    [750] = 252,
+    [751] = 189,
+    [752] = 191,
     [753] = 252,
-    [754] = 252,
-    [755] = 169,
-    [756] = 169,
-    [757] = 169,
-    [758] = 252,
-    [759] = 169,
-    [760] = 169,
-    [761] = 169,
-    [762] = 169,
-    [763] = 169,
-    [764] = 169,
-    [765] = 252,
-    [766] = 252,
-    [767] = 252,
-    [768] = 252,
-    [769] = 252,
-    [770] = 190,
-    [771] = 169,
-    [772] = 252,
-    [773] = 252,
-    [774] = 252,
-    [775] = 239,
-    [776] = 166,
-    [777] = 174,
-    [778] = 122,
-    [779] = 164,
-    [780] = 185,
-    [781] = 217,
-    [782] = 195,
-    [783] = 239,
-    [784] = 166,
-    [785] = 239,
-    [786] = 166,
-    [787] = 185,
+    [754] = 192,
+    [755] = 194,
+    [756] = 251,
+    [757] = 195,
+    [758] = 251,
+    [759] = 251,
+    [760] = 251,
+    [761] = 251,
+    [762] = 251,
+    [763] = 251,
+    [764] = 251,
+    [765] = 251,
+    [766] = 196,
+    [767] = 168,
+    [768] = 196,
+    [769] = 195,
+    [770] = 173,
+    [771] = 251,
+    [772] = 166,
+    [773] = 197,
+    [774] = 198,
+    [775] = 251,
+    [776] = 251,
+    [777] = 173,
+    [778] = 251,
+    [779] = 195,
+    [780] = 173,
+    [781] = 251,
+    [782] = 214,
+    [783] = 216,
+    [784] = 251,
+    [785] = 191,
+    [786] = 251,
+    [787] = 251,
     [788] = 217,
     [789] = 195,
-    [790] = 239,
-    [791] = 166,
-    [792] = 122,
-    [793] = 164,
-    [794] = 185,
-    [795] = 217,
-    [796] = 195,
+    [790] = 251,
+    [791] = 179,
+    [792] = 251,
+    [793] = 197,
+    [794] = 251,
+    [795] = 251,
+    [796] = 217,
     [797] = 239,
     [798] = 166,
-    [799] = 173,
-    [800] = 169,
-    [801] = 217,
-    [802] = 195,
-    [803] = 173,
-    [804] = 254,
-    [805] = 254,
-    [806] = 198,
-    [807] = 166,
-    [808] = 169,
-    [809] = 181,
-    [810] = 266,
-    [811] = 266,
-    [812] = 266,
-    [813] = 122,
-    [814] = 164,
-    [815] = 254,
-    [816] = 165,
+    [799] = 243,
+    [800] = 253,
+    [801] = 164,
+    [802] = 174,
+    [803] = 174,
+    [804] = 122,
+    [805] = 164,
+    [806] = 185,
+    [807] = 217,
+    [808] = 195,
+    [809] = 239,
+    [810] = 166,
+    [811] = 239,
+    [812] = 166,
+    [813] = 185,
+    [814] = 217,
+    [815] = 195,
+    [816] = 239,
     [817] = 166,
-    [818] = 168,
-    [819] = 168,
-    [820] = 168,
-    [821] = 168,
-    [822] = 173,
-    [823] = 174,
-    [824] = 169,
-    [825] = 164,
+    [818] = 122,
+    [819] = 164,
+    [820] = 185,
+    [821] = 217,
+    [822] = 195,
+    [823] = 239,
+    [824] = 166,
+    [825] = 173,
     [826] = 169,
-    [827] = 154,
-    [828] = 278,
-    [829] = 279,
-    [830] = 122,
-    [831] = 280,
-    [832] = 122,
-    [833] = 279,
-    [834] = 280,
-    [835] = 281,
-    [836] = 166,
-    [837] = 197,
-    [838] = 198,
-    [839] = 281,
-    [840] = 281,
-    [841] = 284,
-    [842] = 266,
-    [843] = 168,
-    [844] = 173,
-    [845] = 266,
-    [846] = 166,
-    [847] = 197,
-    [848] = 198,
-    [849] = 266,
-    [850] = 266,
-    [851] = 165,
-    [852] = 195,
-    [853] = 173,
-    [854] = 284,
-    [855] = 166,
-    [856] = 197,
-    [857] = 198,
-    [858] = 284,
-    [859] = 284,
-    [860] = 266,
-    [861] = 239,
-    [862] = 266,
-    [863] = 240,
-    [864] = 174,
-    [865] = 122,
-    [866] = 154,
-    [867] = 165,
-    [868] = 242,
-    [869] = 169,
-    [870] = 217,
-    [871] = 239,
-    [872] = 266,
-    [873] = 169,
-    [874] = 252,
-    [875] = 239,
+    [827] = 217,
+    [828] = 195,
+    [829] = 173,
+    [830] = 254,
+    [831] = 254,
+    [832] = 197,
+    [833] = 166,
+    [834] = 169,
+    [835] = 181,
+    [836] = 266,
+    [837] = 266,
+    [838] = 266,
+    [839] = 122,
+    [840] = 254,
+    [841] = 164,
+    [842] = 165,
+    [843] = 166,
+    [844] = 168,
+    [845] = 168,
+    [846] = 168,
+    [847] = 168,
+    [848] = 173,
+    [849] = 174,
+    [850] = 169,
+    [851] = 164,
+    [852] = 169,
+    [853] = 154,
+    [854] = 278,
+    [855] = 279,
+    [856] = 122,
+    [857] = 280,
+    [858] = 122,
+    [859] = 279,
+    [860] = 280,
+    [861] = 281,
+    [862] = 166,
+    [863] = 197,
+    [864] = 198,
+    [865] = 281,
+    [866] = 281,
+    [867] = 284,
+    [868] = 266,
+    [869] = 168,
+    [870] = 173,
+    [871] = 266,
+    [872] = 166,
+    [873] = 197,
+    [874] = 198,
+    [875] = 266,
     [876] = 266,
-    [877] = 174,
-    [878] = 122,
-    [879] = 164,
-    [880] = 185,
-    [881] = 217,
-    [882] = 195,
-    [883] = 239,
-    [884] = 266,
-    [885] = 239,
+    [877] = 165,
+    [878] = 195,
+    [879] = 173,
+    [880] = 284,
+    [881] = 166,
+    [882] = 197,
+    [883] = 198,
+    [884] = 284,
+    [885] = 284,
     [886] = 266,
-    [887] = 185,
-    [888] = 217,
-    [889] = 195,
-    [890] = 239,
-    [891] = 266,
-    [892] = 122,
-    [893] = 164,
-    [894] = 185,
-    [895] = 217,
-    [896] = 195,
-    [897] = 239,
-    [898] = 266,
-    [899] = 173,
-    [900] = 254,
-    [901] = 198,
+    [887] = 239,
+    [888] = 266,
+    [889] = 240,
+    [890] = 174,
+    [891] = 122,
+    [892] = 165,
+    [893] = 154,
+    [894] = 169,
+    [895] = 241,
+    [896] = 239,
+    [897] = 266,
+    [898] = 244,
+    [899] = 169,
+    [900] = 217,
+    [901] = 239,
     [902] = 266,
-    [903] = 266,
-    [904] = 239,
-    [905] = 285,
-    [906] = 285,
-    [907] = 122,
-    [908] = 164,
-    [909] = 165,
-    [910] = 166,
-    [911] = 168,
-    [912] = 168,
-    [913] = 168,
-    [914] = 168,
-    [915] = 173,
-    [916] = 174,
-    [917] = 169,
-    [918] = 164,
-    [919] = 169,
-    [920] = 154,
-    [921] = 290,
-    [922] = 291,
-    [923] = 122,
-    [924] = 292,
-    [925] = 122,
-    [926] = 291,
-    [927] = 292,
-    [928] = 293,
-    [929] = 166,
-    [930] = 197,
-    [931] = 198,
-    [932] = 293,
-    [933] = 293,
-    [934] = 294,
-    [935] = 285,
-    [936] = 168,
-    [937] = 173,
-    [938] = 285,
-    [939] = 166,
-    [940] = 197,
-    [941] = 198,
-    [942] = 285,
-    [943] = 285,
-    [944] = 165,
-    [945] = 195,
-    [946] = 173,
-    [947] = 294,
-    [948] = 166,
-    [949] = 197,
-    [950] = 198,
-    [951] = 294,
-    [952] = 294,
-    [953] = 285,
-    [954] = 239,
-    [955] = 285,
-    [956] = 240,
-    [957] = 174,
-    [958] = 122,
-    [959] = 154,
-    [960] = 165,
-    [961] = 242,
-    [962] = 169,
-    [963] = 217,
-    [964] = 239,
-    [965] = 285,
-    [966] = 169,
-    [967] = 252,
-    [968] = 239,
+    [903] = 174,
+    [904] = 122,
+    [905] = 164,
+    [906] = 185,
+    [907] = 217,
+    [908] = 195,
+    [909] = 239,
+    [910] = 266,
+    [911] = 239,
+    [912] = 266,
+    [913] = 185,
+    [914] = 217,
+    [915] = 195,
+    [916] = 239,
+    [917] = 266,
+    [918] = 122,
+    [919] = 164,
+    [920] = 185,
+    [921] = 217,
+    [922] = 195,
+    [923] = 239,
+    [924] = 266,
+    [925] = 173,
+    [926] = 254,
+    [927] = 197,
+    [928] = 266,
+    [929] = 266,
+    [930] = 239,
+    [931] = 285,
+    [932] = 285,
+    [933] = 122,
+    [934] = 164,
+    [935] = 165,
+    [936] = 166,
+    [937] = 168,
+    [938] = 168,
+    [939] = 168,
+    [940] = 168,
+    [941] = 173,
+    [942] = 174,
+    [943] = 169,
+    [944] = 164,
+    [945] = 169,
+    [946] = 154,
+    [947] = 290,
+    [948] = 291,
+    [949] = 122,
+    [950] = 292,
+    [951] = 122,
+    [952] = 291,
+    [953] = 292,
+    [954] = 293,
+    [955] = 166,
+    [956] = 197,
+    [957] = 198,
+    [958] = 293,
+    [959] = 293,
+    [960] = 294,
+    [961] = 285,
+    [962] = 168,
+    [963] = 173,
+    [964] = 285,
+    [965] = 166,
+    [966] = 197,
+    [967] = 198,
+    [968] = 285,
     [969] = 285,
-    [970] = 174,
-    [971] = 122,
-    [972] = 164,
-    [973] = 185,
-    [974] = 217,
-    [975] = 195,
-    [976] = 239,
-    [977] = 285,
-    [978] = 239,
+    [970] = 165,
+    [971] = 195,
+    [972] = 173,
+    [973] = 294,
+    [974] = 166,
+    [975] = 197,
+    [976] = 198,
+    [977] = 294,
+    [978] = 294,
     [979] = 285,
-    [980] = 185,
-    [981] = 217,
-    [982] = 195,
-    [983] = 239,
-    [984] = 285,
-    [985] = 122,
-    [986] = 164,
-    [987] = 185,
-    [988] = 217,
-    [989] = 195,
-    [990] = 239,
-    [991] = 285,
-    [992] = 173,
-    [993] = 254,
-    [994] = 198,
+    [980] = 239,
+    [981] = 285,
+    [982] = 240,
+    [983] = 174,
+    [984] = 122,
+    [985] = 165,
+    [986] = 154,
+    [987] = 169,
+    [988] = 241,
+    [989] = 239,
+    [990] = 285,
+    [991] = 244,
+    [992] = 169,
+    [993] = 217,
+    [994] = 239,
     [995] = 285,
-    [996] = 285,
-    [997] = 239,
-    [998] = 285,
-    [999] = 239,
-    [1000] = 285,
-    [1001] = 295,
-    [1002] = 296,
-    [1003] = 297,
-    [1004] = 292,
-    [1005] = 169,
-    [1006] = 169,
-    [1007] = 122,
-    [1008] = 122,
-    [1009] = 198,
-    [1010] = 292,
+    [996] = 174,
+    [997] = 122,
+    [998] = 164,
+    [999] = 185,
+    [1000] = 217,
+    [1001] = 195,
+    [1002] = 239,
+    [1003] = 285,
+    [1004] = 239,
+    [1005] = 285,
+    [1006] = 185,
+    [1007] = 217,
+    [1008] = 195,
+    [1009] = 239,
+    [1010] = 285,
     [1011] = 122,
-    [1012] = 241,
-    [1013] = 251,
-    [1014] = 298,
-    [1015] = 164,
-    [1016] = 291,
-    [1017] = 292,
-    [1018] = 239,
-    [1019] = 266,
-    [1020] = 295,
-    [1021] = 280,
-    [1022] = 280,
-    [1023] = 241,
-    [1024] = 251,
-    [1025] = 299,
-    [1026] = 164,
-    [1027] = 279,
-    [1028] = 280,
-    [1029] = 254,
-    [1030] = 190,
-    [1031] = 266,
-    [1032] = 254,
-    [1033] = 166,
-    [1034] = 198,
-    [1035] = 239,
-    [1036] = 300,
-    [1037] = 300,
-    [1038] = 122,
-    [1039] = 164,
-    [1040] = 165,
-    [1041] = 166,
-    [1042] = 168,
-    [1043] = 168,
-    [1044] = 168,
-    [1045] = 168,
-    [1046] = 173,
-    [1047] = 174,
-    [1048] = 169,
-    [1049] = 164,
-    [1050] = 169,
-    [1051] = 154,
-    [1052] = 301,
-    [1053] = 302,
-    [1054] = 122,
-    [1055] = 303,
-    [1056] = 122,
-    [1057] = 302,
-    [1058] = 303,
-    [1059] = 304,
-    [1060] = 166,
-    [1061] = 197,
-    [1062] = 198,
-    [1063] = 304,
-    [1064] = 304,
-    [1065] = 305,
-    [1066] = 300,
+    [1012] = 164,
+    [1013] = 185,
+    [1014] = 217,
+    [1015] = 195,
+    [1016] = 239,
+    [1017] = 285,
+    [1018] = 173,
+    [1019] = 254,
+    [1020] = 197,
+    [1021] = 285,
+    [1022] = 285,
+    [1023] = 239,
+    [1024] = 285,
+    [1025] = 239,
+    [1026] = 285,
+    [1027] = 295,
+    [1028] = 292,
+    [1029] = 296,
+    [1030] = 297,
+    [1031] = 197,
+    [1032] = 292,
+    [1033] = 122,
+    [1034] = 243,
+    [1035] = 253,
+    [1036] = 164,
+    [1037] = 298,
+    [1038] = 291,
+    [1039] = 292,
+    [1040] = 239,
+    [1041] = 266,
+    [1042] = 295,
+    [1043] = 280,
+    [1044] = 280,
+    [1045] = 243,
+    [1046] = 253,
+    [1047] = 164,
+    [1048] = 299,
+    [1049] = 279,
+    [1050] = 280,
+    [1051] = 254,
+    [1052] = 187,
+    [1053] = 266,
+    [1054] = 254,
+    [1055] = 166,
+    [1056] = 197,
+    [1057] = 239,
+    [1058] = 300,
+    [1059] = 300,
+    [1060] = 122,
+    [1061] = 164,
+    [1062] = 165,
+    [1063] = 166,
+    [1064] = 168,
+    [1065] = 168,
+    [1066] = 168,
     [1067] = 168,
     [1068] = 173,
-    [1069] = 300,
-    [1070] = 166,
-    [1071] = 197,
-    [1072] = 198,
-    [1073] = 300,
-    [1074] = 300,
-    [1075] = 165,
-    [1076] = 195,
-    [1077] = 173,
-    [1078] = 305,
-    [1079] = 166,
-    [1080] = 197,
-    [1081] = 198,
-    [1082] = 305,
-    [1083] = 305,
-    [1084] = 300,
-    [1085] = 239,
-    [1086] = 300,
-    [1087] = 240,
-    [1088] = 174,
-    [1089] = 122,
-    [1090] = 154,
-    [1091] = 165,
-    [1092] = 242,
-    [1093] = 169,
-    [1094] = 217,
-    [1095] = 239,
+    [1069] = 174,
+    [1070] = 169,
+    [1071] = 164,
+    [1072] = 169,
+    [1073] = 154,
+    [1074] = 301,
+    [1075] = 302,
+    [1076] = 122,
+    [1077] = 303,
+    [1078] = 122,
+    [1079] = 302,
+    [1080] = 303,
+    [1081] = 304,
+    [1082] = 166,
+    [1083] = 197,
+    [1084] = 198,
+    [1085] = 304,
+    [1086] = 304,
+    [1087] = 305,
+    [1088] = 300,
+    [1089] = 168,
+    [1090] = 173,
+    [1091] = 300,
+    [1092] = 166,
+    [1093] = 197,
+    [1094] = 198,
+    [1095] = 300,
     [1096] = 300,
-    [1097] = 169,
-    [1098] = 252,
-    [1099] = 239,
-    [1100] = 300,
-    [1101] = 174,
-    [1102] = 122,
-    [1103] = 164,
-    [1104] = 185,
-    [1105] = 217,
-    [1106] = 195,
+    [1097] = 165,
+    [1098] = 195,
+    [1099] = 173,
+    [1100] = 305,
+    [1101] = 166,
+    [1102] = 197,
+    [1103] = 198,
+    [1104] = 305,
+    [1105] = 305,
+    [1106] = 300,
     [1107] = 239,
     [1108] = 300,
-    [1109] = 239,
-    [1110] = 300,
-    [1111] = 185,
-    [1112] = 217,
-    [1113] = 195,
-    [1114] = 239,
-    [1115] = 300,
-    [1116] = 122,
-    [1117] = 164,
-    [1118] = 185,
-    [1119] = 217,
-    [1120] = 195,
+    [1109] = 240,
+    [1110] = 174,
+    [1111] = 122,
+    [1112] = 165,
+    [1113] = 154,
+    [1114] = 169,
+    [1115] = 241,
+    [1116] = 239,
+    [1117] = 300,
+    [1118] = 244,
+    [1119] = 169,
+    [1120] = 217,
     [1121] = 239,
     [1122] = 300,
-    [1123] = 173,
-    [1124] = 254,
-    [1125] = 198,
-    [1126] = 300,
-    [1127] = 300,
-    [1128] = 239,
-    [1129] = 300,
-    [1130] = 239,
-    [1131] = 300,
-    [1132] = 295,
-    [1133] = 303,
-    [1134] = 303,
-    [1135] = 241,
-    [1136] = 251,
-    [1137] = 306,
-    [1138] = 164,
-    [1139] = 302,
-    [1140] = 303,
-    [1141] = 239,
-    [1142] = 166,
-    [1143] = 295,
-    [1144] = 224,
-    [1145] = 224,
-    [1146] = 241,
-    [1147] = 251,
-    [1148] = 307,
-    [1149] = 164,
-    [1150] = 223,
-    [1151] = 192,
-    [1152] = 198,
-    [1153] = 195,
-    [1154] = 165,
-    [1155] = 194,
-    [1156] = 195,
-    [1157] = 173,
-    [1158] = 192,
-    [1159] = 196,
-    [1160] = 195,
-    [1161] = 173,
-    [1162] = 192,
-    [1163] = 214,
-    [1164] = 216,
-    [1165] = 192,
-    [1166] = 189,
-    [1167] = 192,
-    [1168] = 192,
-    [1169] = 217,
-    [1170] = 195,
-    [1171] = 192,
-    [1172] = 179,
+    [1123] = 174,
+    [1124] = 122,
+    [1125] = 164,
+    [1126] = 185,
+    [1127] = 217,
+    [1128] = 195,
+    [1129] = 239,
+    [1130] = 300,
+    [1131] = 239,
+    [1132] = 300,
+    [1133] = 185,
+    [1134] = 217,
+    [1135] = 195,
+    [1136] = 239,
+    [1137] = 300,
+    [1138] = 122,
+    [1139] = 164,
+    [1140] = 185,
+    [1141] = 217,
+    [1142] = 195,
+    [1143] = 239,
+    [1144] = 300,
+    [1145] = 173,
+    [1146] = 254,
+    [1147] = 197,
+    [1148] = 300,
+    [1149] = 300,
+    [1150] = 239,
+    [1151] = 300,
+    [1152] = 239,
+    [1153] = 300,
+    [1154] = 295,
+    [1155] = 303,
+    [1156] = 303,
+    [1157] = 243,
+    [1158] = 253,
+    [1159] = 164,
+    [1160] = 306,
+    [1161] = 302,
+    [1162] = 303,
+    [1163] = 239,
+    [1164] = 166,
+    [1165] = 295,
+    [1166] = 224,
+    [1167] = 224,
+    [1168] = 243,
+    [1169] = 253,
+    [1170] = 164,
+    [1171] = 307,
+    [1172] = 223,
     [1173] = 192,
-    [1174] = 198,
-    [1175] = 192,
+    [1174] = 197,
+    [1175] = 173,
     [1176] = 192,
-    [1177] = 169,
-    [1178] = 169,
+    [1177] = 195,
+    [1178] = 173,
     [1179] = 192,
-    [1180] = 192,
-    [1181] = 195,
-    [1182] = 190,
-    [1183] = 190,
-    [1184] = 190,
-    [1185] = 190,
-    [1186] = 190,
-    [1187] = 168,
-    [1188] = 196,
-    [1189] = 195,
-    [1190] = 173,
-    [1191] = 190,
-    [1192] = 166,
-    [1193] = 197,
-    [1194] = 198,
-    [1195] = 190,
-    [1196] = 190,
-    [1197] = 173,
-    [1198] = 190,
-    [1199] = 196,
-    [1200] = 195,
-    [1201] = 173,
-    [1202] = 190,
-    [1203] = 214,
-    [1204] = 216,
-    [1205] = 190,
-    [1206] = 189,
-    [1207] = 190,
-    [1208] = 190,
-    [1209] = 217,
-    [1210] = 195,
-    [1211] = 190,
-    [1212] = 179,
-    [1213] = 190,
-    [1214] = 198,
-    [1215] = 190,
-    [1216] = 190,
-    [1217] = 169,
-    [1218] = 169,
-    [1219] = 190,
-    [1220] = 190,
-    [1221] = 169,
-    [1222] = 187,
-    [1223] = 187,
-    [1224] = 192,
-    [1225] = 194,
-    [1226] = 187,
-    [1227] = 195,
-    [1228] = 187,
-    [1229] = 187,
-    [1230] = 187,
-    [1231] = 187,
-    [1232] = 187,
-    [1233] = 168,
-    [1234] = 196,
-    [1235] = 195,
-    [1236] = 173,
-    [1237] = 187,
-    [1238] = 166,
-    [1239] = 197,
-    [1240] = 198,
+    [1180] = 214,
+    [1181] = 216,
+    [1182] = 192,
+    [1183] = 191,
+    [1184] = 192,
+    [1185] = 192,
+    [1186] = 217,
+    [1187] = 195,
+    [1188] = 192,
+    [1189] = 179,
+    [1190] = 192,
+    [1191] = 197,
+    [1192] = 192,
+    [1193] = 192,
+    [1194] = 195,
+    [1195] = 189,
+    [1196] = 189,
+    [1197] = 189,
+    [1198] = 189,
+    [1199] = 189,
+    [1200] = 189,
+    [1201] = 189,
+    [1202] = 189,
+    [1203] = 196,
+    [1204] = 168,
+    [1205] = 196,
+    [1206] = 195,
+    [1207] = 173,
+    [1208] = 189,
+    [1209] = 166,
+    [1210] = 197,
+    [1211] = 198,
+    [1212] = 189,
+    [1213] = 189,
+    [1214] = 173,
+    [1215] = 189,
+    [1216] = 195,
+    [1217] = 173,
+    [1218] = 189,
+    [1219] = 214,
+    [1220] = 216,
+    [1221] = 189,
+    [1222] = 191,
+    [1223] = 189,
+    [1224] = 189,
+    [1225] = 217,
+    [1226] = 195,
+    [1227] = 189,
+    [1228] = 179,
+    [1229] = 189,
+    [1230] = 197,
+    [1231] = 189,
+    [1232] = 189,
+    [1233] = 188,
+    [1234] = 192,
+    [1235] = 194,
+    [1236] = 187,
+    [1237] = 195,
+    [1238] = 187,
+    [1239] = 187,
+    [1240] = 187,
     [1241] = 187,
     [1242] = 187,
-    [1243] = 173,
+    [1243] = 187,
     [1244] = 187,
-    [1245] = 196,
-    [1246] = 195,
-    [1247] = 173,
-    [1248] = 187,
-    [1249] = 214,
-    [1250] = 216,
+    [1245] = 187,
+    [1246] = 196,
+    [1247] = 168,
+    [1248] = 196,
+    [1249] = 195,
+    [1250] = 173,
     [1251] = 187,
-    [1252] = 189,
-    [1253] = 187,
-    [1254] = 187,
-    [1255] = 217,
-    [1256] = 195,
-    [1257] = 187,
-    [1258] = 179,
-    [1259] = 187,
-    [1260] = 198,
+    [1252] = 166,
+    [1253] = 197,
+    [1254] = 198,
+    [1255] = 187,
+    [1256] = 187,
+    [1257] = 173,
+    [1258] = 187,
+    [1259] = 195,
+    [1260] = 173,
     [1261] = 187,
-    [1262] = 187,
-    [1263] = 169,
-    [1264] = 169,
-    [1265] = 187,
+    [1262] = 214,
+    [1263] = 216,
+    [1264] = 187,
+    [1265] = 191,
     [1266] = 187,
-    [1267] = 184,
-    [1268] = 192,
-    [1269] = 194,
-    [1270] = 183,
-    [1271] = 195,
-    [1272] = 183,
-    [1273] = 183,
-    [1274] = 183,
-    [1275] = 183,
-    [1276] = 183,
-    [1277] = 168,
-    [1278] = 196,
-    [1279] = 195,
-    [1280] = 173,
-    [1281] = 183,
-    [1282] = 166,
-    [1283] = 197,
-    [1284] = 198,
-    [1285] = 183,
+    [1267] = 187,
+    [1268] = 217,
+    [1269] = 195,
+    [1270] = 187,
+    [1271] = 179,
+    [1272] = 187,
+    [1273] = 197,
+    [1274] = 187,
+    [1275] = 187,
+    [1276] = 169,
+    [1277] = 183,
+    [1278] = 184,
+    [1279] = 189,
+    [1280] = 191,
+    [1281] = 184,
+    [1282] = 192,
+    [1283] = 194,
+    [1284] = 183,
+    [1285] = 195,
     [1286] = 183,
-    [1287] = 173,
+    [1287] = 183,
     [1288] = 183,
-    [1289] = 196,
-    [1290] = 195,
-    [1291] = 173,
+    [1289] = 183,
+    [1290] = 183,
+    [1291] = 183,
     [1292] = 183,
-    [1293] = 214,
-    [1294] = 216,
-    [1295] = 183,
-    [1296] = 189,
-    [1297] = 183,
-    [1298] = 183,
-    [1299] = 217,
-    [1300] = 195,
-    [1301] = 183,
-    [1302] = 179,
+    [1293] = 183,
+    [1294] = 196,
+    [1295] = 168,
+    [1296] = 196,
+    [1297] = 195,
+    [1298] = 173,
+    [1299] = 183,
+    [1300] = 166,
+    [1301] = 197,
+    [1302] = 198,
     [1303] = 183,
-    [1304] = 198,
-    [1305] = 183,
+    [1304] = 183,
+    [1305] = 173,
     [1306] = 183,
-    [1307] = 169,
-    [1308] = 169,
-    [1309] = 169,
-    [1310] = 183,
-    [1311] = 169,
-    [1312] = 169,
-    [1313] = 169,
-    [1314] = 169,
-    [1315] = 169,
-    [1316] = 169,
-    [1317] = 183,
+    [1307] = 195,
+    [1308] = 173,
+    [1309] = 183,
+    [1310] = 214,
+    [1311] = 216,
+    [1312] = 183,
+    [1313] = 191,
+    [1314] = 183,
+    [1315] = 183,
+    [1316] = 217,
+    [1317] = 195,
     [1318] = 183,
-    [1319] = 183,
+    [1319] = 179,
     [1320] = 183,
-    [1321] = 183,
-    [1322] = 190,
-    [1323] = 169,
-    [1324] = 183,
-    [1325] = 183,
-    [1326] = 183,
+    [1321] = 197,
+    [1322] = 183,
+    [1323] = 183,
+    [1324] = 122,
+    [1325] = 122,
+    [1326] = 122,
     [1327] = 122,
     [1328] = 122,
     [1329] = 122,
     [1330] = 122,
-    [1331] = 168,
-    [1332] = 196,
-    [1333] = 195,
-    [1334] = 173,
-    [1335] = 122,
-    [1336] = 166,
-    [1337] = 197,
-    [1338] = 198,
-    [1339] = 122,
+    [1331] = 196,
+    [1332] = 168,
+    [1333] = 196,
+    [1334] = 195,
+    [1335] = 173,
+    [1336] = 122,
+    [1337] = 166,
+    [1338] = 197,
+    [1339] = 198,
     [1340] = 122,
-    [1341] = 173,
-    [1342] = 122,
-    [1343] = 196,
+    [1341] = 122,
+    [1342] = 173,
+    [1343] = 122,
     [1344] = 195,
     [1345] = 173,
     [1346] = 122,
     [1347] = 214,
     [1348] = 216,
     [1349] = 122,
-    [1350] = 189,
+    [1350] = 191,
     [1351] = 122,
     [1352] = 122,
     [1353] = 154,
@@ -8306,15 +8306,15 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [1392] = 240,
     [1393] = 174,
     [1394] = 122,
-    [1395] = 154,
-    [1396] = 165,
-    [1397] = 242,
-    [1398] = 169,
-    [1399] = 217,
-    [1400] = 239,
-    [1401] = 1,
+    [1395] = 165,
+    [1396] = 154,
+    [1397] = 169,
+    [1398] = 241,
+    [1399] = 239,
+    [1400] = 1,
+    [1401] = 244,
     [1402] = 169,
-    [1403] = 252,
+    [1403] = 217,
     [1404] = 239,
     [1405] = 1,
     [1406] = 174,
@@ -8341,7 +8341,7 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [1427] = 1,
     [1428] = 173,
     [1429] = 254,
-    [1430] = 198,
+    [1430] = 197,
     [1431] = 1,
     [1432] = 1,
     [1433] = 239,
@@ -8399,15 +8399,15 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [1485] = 240,
     [1486] = 174,
     [1487] = 122,
-    [1488] = 154,
-    [1489] = 165,
-    [1490] = 242,
-    [1491] = 169,
-    [1492] = 217,
-    [1493] = 239,
-    [1494] = 313,
+    [1488] = 165,
+    [1489] = 154,
+    [1490] = 169,
+    [1491] = 241,
+    [1492] = 239,
+    [1493] = 313,
+    [1494] = 244,
     [1495] = 169,
-    [1496] = 252,
+    [1496] = 217,
     [1497] = 239,
     [1498] = 313,
     [1499] = 174,
@@ -8434,7 +8434,7 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [1520] = 313,
     [1521] = 173,
     [1522] = 254,
-    [1523] = 198,
+    [1523] = 197,
     [1524] = 313,
     [1525] = 313,
     [1526] = 239,
@@ -8444,10 +8444,10 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [1530] = 295,
     [1531] = 316,
     [1532] = 316,
-    [1533] = 241,
-    [1534] = 251,
-    [1535] = 319,
-    [1536] = 164,
+    [1533] = 243,
+    [1534] = 253,
+    [1535] = 164,
+    [1536] = 319,
     [1537] = 315,
     [1538] = 316,
     [1539] = 239,
@@ -8455,10 +8455,10 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [1541] = 295,
     [1542] = 310,
     [1543] = 310,
-    [1544] = 241,
-    [1545] = 251,
-    [1546] = 320,
-    [1547] = 164,
+    [1544] = 243,
+    [1545] = 253,
+    [1546] = 164,
+    [1547] = 320,
     [1548] = 309,
     [1549] = 310,
     [1550] = 119,
@@ -8500,36 +8500,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 0)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(9)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1] = {
         [ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
@@ -8567,36 +8567,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1550)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1550)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [3] = {
         [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -8629,8 +8629,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -8641,165 +8659,118 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
     },
     [4] = {
         [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [5] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1549)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1549)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1549)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
     [6] = {
         [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(28)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1005)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [7] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1549)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1549)),
-    },
-    [8] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1005)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [9] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [10] = {
+    [8] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1549)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1549)),
+    },
+    [9] = {
         [sym_var_assignment] = ACTIONS(SHIFT(1544)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1544)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_identifier] = ACTIONS(SHIFT(1545)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [11] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [10] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -8814,104 +8785,104 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_pair] = ACTIONS(SHIFT(29)),
+        [sym_pair] = ACTIONS(SHIFT(32)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1373)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1542)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(1002)),
+        [sym_string] = ACTIONS(SHIFT(1029)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(1003)),
+        [sym_identifier] = ACTIONS(SHIFT(1030)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1374)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1542)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [11] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(1433)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [12] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(1433)),
+        [sym__paren_expression] = ACTIONS(SHIFT(1428)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(826)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
     },
     [13] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(1428)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1392)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(800)),
     },
     [14] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1389)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1390)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1392)),
     },
     [15] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1389)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1390)),
+        [sym__paren_expression] = ACTIONS(SHIFT(1387)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [16] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(1387)),
+        [sym_statement_block] = ACTIONS(SHIFT(1361)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1362)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
     },
     [17] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1361)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1362)),
-    },
-    [18] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
         [sym__expression] = ACTIONS(SHIFT(1358)),
         [sym_object] = ACTIONS(SHIFT(4)),
@@ -8928,26 +8899,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1359)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT(1359)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1359)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [19] = {
+    [18] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
         [sym__expression] = ACTIONS(SHIFT(1356)),
         [sym_object] = ACTIONS(SHIFT(4)),
@@ -8964,108 +8935,108 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [20] = {
+    [19] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1355)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1355)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1355)),
     },
-    [21] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(199)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
+    [20] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(227)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
         [sym_member_access] = ACTIONS(SHIFT(1353)),
         [sym_subscript_access] = ACTIONS(SHIFT(1353)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [21] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(1347)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1348)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1349)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
     },
     [22] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(1347)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1348)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1331)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
+        [sym_identifier] = ACTIONS(SHIFT(1332)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1349)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
     },
     [23] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1331)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1332)),
-    },
-    [24] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
         [sym__expression] = ACTIONS(SHIFT(1329)),
         [sym_object] = ACTIONS(SHIFT(4)),
@@ -9082,25 +9053,25 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [25] = {
+    [24] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
         [sym__expression] = ACTIONS(SHIFT(1328)),
         [sym_object] = ACTIONS(SHIFT(4)),
@@ -9117,27 +9088,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [26] = {
+    [25] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(27)),
+        [sym__expression] = ACTIONS(SHIFT(1327)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -9152,4010 +9123,4788 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [26] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(28)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
     [27] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(1326)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [28] = {
-        [sym_pair] = ACTIONS(SHIFT(29)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(29)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(1325)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(31)),
     },
     [29] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(30)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1009)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1327)),
     },
     [30] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(32)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
     },
     [31] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_pair] = ACTIONS(SHIFT(32)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(32)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(33)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [32] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(34)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1031)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1324)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [33] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
     },
     [34] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(35)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_pair, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_pair, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_pair, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1307)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(1311)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(1312)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(1313)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(1307)),
     },
     [35] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(37)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1308)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [36] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1307)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1308)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1309)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
     [37] = {
-        [sym_pair] = ACTIONS(SHIFT(1302)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1302)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_pair, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_pair, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_pair, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(SHIFT(47)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(55)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(56)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(57)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_LT] = ACTIONS(SHIFT(61)),
+        [aux_sym_GT] = ACTIONS(SHIFT(61)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(47)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1303)),
     },
     [38] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1299)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1300)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [39] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(1293)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1294)),
+        [sym_pair] = ACTIONS(SHIFT(1319)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1319)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1320)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1295)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
     },
     [40] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1316)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1317)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1277)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1278)),
     },
     [41] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1275)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(1310)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1311)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1312)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [42] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1274)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1294)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
+        [sym_identifier] = ACTIONS(SHIFT(1295)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [43] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(44)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(1292)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [44] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(1291)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
     },
     [45] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(1290)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
     },
     [46] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(1268)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1269)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(47)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(48)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(49)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1270)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [47] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(52)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(54)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(1289)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [48] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(1288)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(50)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [49] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(50)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
     },
     [50] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(SHIFT(47)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(55)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(56)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(57)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_LT] = ACTIONS(SHIFT(61)),
+        [aux_sym_GT] = ACTIONS(SHIFT(61)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(47)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
     },
     [51] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [52] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(1282)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1283)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1284)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1267)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [53] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(1279)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1280)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1263)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [54] = {
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1278)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1267)),
     },
     [55] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(68)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1263)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1264)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
     [56] = {
-        [sym_pair] = ACTIONS(SHIFT(1258)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1258)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(66)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1259)),
     },
     [57] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1255)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1256)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(65)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [58] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(1249)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1250)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1251)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
     },
     [59] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(64)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1233)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1234)),
     },
     [60] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(1231)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(63)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [61] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(1230)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(62)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [62] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(63)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [63] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
     },
     [64] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
     },
     [65] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(1224)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1225)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(SHIFT(47)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_LT] = ACTIONS(SHIFT(61)),
+        [aux_sym_GT] = ACTIONS(SHIFT(61)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(47)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1226)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [66] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(70)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(71)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(SHIFT(47)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(57)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_LT] = ACTIONS(SHIFT(61)),
+        [aux_sym_GT] = ACTIONS(SHIFT(61)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(47)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [67] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(69)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [68] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(1276)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
     },
     [69] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(79)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
     },
     [70] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym_pair] = ACTIONS(SHIFT(1271)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1271)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1272)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(72)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [71] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1268)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1269)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(72)),
     },
     [72] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(1262)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1263)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1264)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
     },
     [73] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(1223)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1246)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_identifier] = ACTIONS(SHIFT(1247)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [74] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(86)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(1244)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [75] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(84)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(1243)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [76] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(83)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(1242)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [77] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(82)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(79)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(80)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [78] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(81)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(1241)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [79] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(80)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(1240)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [80] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(81)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
     },
     [81] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [82] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [83] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(1234)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1235)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1236)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [84] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(103)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(105)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [85] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(101)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [86] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(98)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(1221)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
     [87] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(97)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1217)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [88] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(96)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1217)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
     [89] = {
-        [sym_pair] = ACTIONS(SHIFT(1212)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1212)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1213)),
     },
     [90] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1209)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(95)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [91] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(1203)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1204)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(94)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1205)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
     },
     [92] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(93)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1187)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1188)),
     },
     [93] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(1185)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [94] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(1184)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [95] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(96)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [96] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
     },
     [97] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
     },
     [98] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(107)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(109)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(99)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(113)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [99] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(103)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(104)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(100)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [100] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [101] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
     },
     [102] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
     },
     [103] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1233)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(105)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [104] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(115)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(105)),
     },
     [105] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1233)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
     },
     [106] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_pair] = ACTIONS(SHIFT(1228)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1228)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1229)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [107] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1225)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1181)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1182)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [108] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(1219)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1220)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1221)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1177)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [109] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1203)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1204)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1181)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1182)),
     },
     [110] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(1201)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1177)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1178)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
     [111] = {
-        [sym_pair] = ACTIONS(SHIFT(1172)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1172)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(1200)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1173)),
     },
     [112] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1169)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1170)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(1199)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [113] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(115)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(116)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
     },
     [114] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(1163)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1164)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(1198)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1165)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
     },
     [115] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(1197)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(174)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(175)),
     },
     [116] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(172)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(117)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [117] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(171)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [118] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(119)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [119] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(142)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(144)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(147)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
     },
     [120] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(138)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(139)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
     },
     [121] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(129)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(130)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
+        [sym_identifier] = ACTIONS(SHIFT(137)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(131)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [122] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(126)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(127)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(134)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [123] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(133)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(125)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [124] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(132)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
     },
     [125] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
     },
     [126] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(131)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(128)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [127] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(130)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(128)),
     },
     [128] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(129)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
     },
     [129] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(132)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(134)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [130] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(132)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(134)),
     },
     [131] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
     },
     [132] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(170)),
     },
     [133] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(135)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(136)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [134] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(135)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
     },
     [135] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(136)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(137)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [136] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(137)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
     },
     [137] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3)),
     },
     [138] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(169)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(140)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [139] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(150)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(140)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [140] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(149)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [141] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(148)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [142] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(147)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1194)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1195)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [143] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(146)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(155)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [144] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(145)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1194)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1195)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [145] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_pair] = ACTIONS(SHIFT(1189)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1189)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1190)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
     },
     [146] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1186)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1187)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [147] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [148] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(1180)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1181)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1182)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [149] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(197)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(198)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [150] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(195)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(152)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
     [151] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(168)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(194)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [152] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(167)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(193)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [153] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(164)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(155)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(156)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [154] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(163)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(192)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [155] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(162)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(191)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [156] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(161)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(157)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [157] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(160)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [158] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(159)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [159] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(181)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(182)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(183)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
     },
     [160] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(178)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(179)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [161] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [162] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [163] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [164] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(165)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [165] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(166)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
-    },
-    [166] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [167] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
-    },
-    [168] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [169] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [170] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
-    },
-    [171] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-    },
-    [172] = {
-        [sym_arguments] = ACTIONS(SHIFT(173)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-    },
-    [173] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-    },
-    [174] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1159)),
-    },
-    [175] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(176)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(178)),
+    },
+    [162] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(174)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [163] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(173)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [164] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(172)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [165] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [166] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(171)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [167] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(170)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [168] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(169)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [169] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [170] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [171] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [172] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [173] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [174] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(175)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [175] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(176)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [176] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1157)),
     },
     [177] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_formal_parameters_repeat1] = ACTIONS(SHIFT(1153)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(1154)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_formal_parameters, 1)),
     },
     [178] = {
-        [sym_statement_block] = ACTIONS(SHIFT(179)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(180)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(180)),
     },
     [179] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(180)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [180] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(184)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(185)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(188)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [181] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(184)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(186)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [182] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(184)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(186)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [183] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [184] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(190)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [185] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(187)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(188)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [186] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [187] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(189)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [188] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(189)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [189] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [190] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [191] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [192] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [193] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [194] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [195] = {
+        [sym_arguments] = ACTIONS(SHIFT(196)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [196] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [197] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(1177)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1178)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [198] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(199)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [199] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(200)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(201)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [200] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1175)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [201] = {
+        [sym_statement_block] = ACTIONS(SHIFT(207)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(208)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [202] = {
+        [aux_sym_formal_parameters_repeat1] = ACTIONS(SHIFT(203)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(204)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_formal_parameters, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [203] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_formal_parameters, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [204] = {
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(205)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [205] = {
+        [aux_sym_formal_parameters_repeat1] = ACTIONS(SHIFT(206)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(204)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_formal_parameters_repeat1, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [206] = {
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(aux_sym_formal_parameters_repeat1, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [207] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [208] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -13170,38 +13919,100 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(212)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(213)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(216)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1152)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [182] = {
+    [209] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1174)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [210] = {
         [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -13232,7 +14043,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -13243,1673 +14073,170 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
-    },
-    [183] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
-    },
-    [184] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1151)),
-    },
-    [185] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1151)),
-    },
-    [186] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(1146)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1146)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1147)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [187] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_pair] = ACTIONS(SHIFT(29)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1143)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(1002)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(1003)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(496)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1144)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [188] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-    },
-    [189] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(1035)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
-    },
-    [190] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(799)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(800)),
-    },
-    [191] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(516)),
-    },
-    [192] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(509)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
-    },
-    [193] = {
-        [sym_statement_block] = ACTIONS(SHIFT(483)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(484)),
-    },
-    [194] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(480)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT(481)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(481)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [195] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(453)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [196] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(452)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(452)),
-    },
-    [197] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(199)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(200)),
-        [sym_subscript_access] = ACTIONS(SHIFT(200)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [198] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [199] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(216)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(219)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(221)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(216)),
-    },
-    [200] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(445)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(445)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [201] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(216)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [202] = {
-        [sym_pair] = ACTIONS(SHIFT(440)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(440)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(441)),
-    },
-    [203] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(437)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(438)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [204] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(267)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(269)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(274)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [205] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(249)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(250)),
-    },
-    [206] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(247)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [207] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(246)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [208] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(209)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [209] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-    },
-    [210] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [211] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(245)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [212] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(213)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1173)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
     },
     [213] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1173)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(216)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(219)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(221)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(216)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [214] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_var_assignment] = ACTIONS(SHIFT(1168)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1168)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1169)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
     },
     [215] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(239)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(240)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [sym_pair] = ACTIONS(SHIFT(32)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(521)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1165)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1166)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
+        [sym_string] = ACTIONS(SHIFT(1029)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(1030)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(241)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [216] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(238)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
     },
     [217] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(235)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(236)),
+        [sym__paren_expression] = ACTIONS(SHIFT(1057)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [218] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(825)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(826)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(234)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [219] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(231)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(542)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [220] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(230)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+        [sym__paren_expression] = ACTIONS(SHIFT(535)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
     },
     [221] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(229)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+        [sym_statement_block] = ACTIONS(SHIFT(509)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(510)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
     },
     [222] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
-    },
-    [223] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(228)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [224] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(227)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [225] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(226)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [226] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-    },
-    [227] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [228] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [229] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(216)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(216)),
-    },
-    [230] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(216)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(221)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(216)),
-    },
-    [231] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(232)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [232] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(233)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(210)),
-        [sym_subscript_access] = ACTIONS(SHIFT(210)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [233] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(216)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(219)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(221)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(216)),
-    },
-    [234] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
-    },
-    [235] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(237)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
-    },
-    [236] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(237)),
-    },
-    [237] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-    },
-    [238] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [239] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(242)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(243)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
-    },
-    [240] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(242)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(243)),
-    },
-    [241] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
-    },
-    [242] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(244)),
-    },
-    [243] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
-    },
-    [244] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
-    },
-    [245] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(216)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(219)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(220)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(221)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(223)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(224)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(225)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(216)),
-    },
-    [246] = {
-        [sym_arguments] = ACTIONS(SHIFT(214)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(222)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-    },
-    [247] = {
-        [sym_arguments] = ACTIONS(SHIFT(248)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(215)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(217)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(218)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-    },
-    [248] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-    },
-    [249] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(262)),
-    },
-    [250] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(251)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(252)),
-    },
-    [251] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(260)),
-    },
-    [252] = {
-        [sym_statement_block] = ACTIONS(SHIFT(253)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(254)),
-    },
-    [253] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
-    },
-    [254] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(506)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -14924,95 +14251,1563 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(255)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(507)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT(507)),
+    },
+    [223] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(481)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(256)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(257)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [224] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(480)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(480)),
+    },
+    [225] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(227)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(228)),
+        [sym_subscript_access] = ACTIONS(SHIFT(228)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [226] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [227] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(SHIFT(237)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(246)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(247)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(248)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(237)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [228] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(473)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(473)),
+    },
+    [229] = {
+        [sym_pair] = ACTIONS(SHIFT(468)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(468)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(469)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [230] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(465)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(466)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [231] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(295)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(297)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(301)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [232] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(277)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(278)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [233] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(275)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [234] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(274)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [235] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(273)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [236] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(237)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [237] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(272)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [238] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(271)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [239] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(240)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [240] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(SHIFT(237)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(246)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(247)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(248)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(237)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [241] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [242] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [243] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(265)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(266)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(267)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [244] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(262)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(263)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [245] = {
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(261)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [246] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(258)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [247] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(257)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [248] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(256)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [249] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [250] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(255)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [251] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(254)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [252] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(253)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [253] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [254] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [255] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(258)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [256] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(SHIFT(237)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(237)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(258)),
     },
     [257] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(SHIFT(237)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(248)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(237)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [258] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(259)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [259] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(260)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(241)),
+        [sym_subscript_access] = ACTIONS(SHIFT(241)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [260] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(SHIFT(237)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(246)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(247)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(248)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(237)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [261] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [262] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(264)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [263] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(264)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [264] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [265] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(268)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(269)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [266] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(268)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(269)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [267] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [268] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(270)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [269] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [270] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [271] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(SHIFT(237)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(246)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(247)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(248)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(252)),
+        [aux_sym_LT] = ACTIONS(SHIFT(252)),
+        [aux_sym_GT] = ACTIONS(SHIFT(252)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(237)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [272] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(250)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(250)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(251)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(251)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [273] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [274] = {
+        [sym_arguments] = ACTIONS(SHIFT(242)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(249)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(249)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [275] = {
+        [sym_arguments] = ACTIONS(SHIFT(276)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(243)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(244)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(245)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [276] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [277] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(291)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(292)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [278] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(279)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [279] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(280)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(281)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [280] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(289)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [281] = {
+        [sym_statement_block] = ACTIONS(SHIFT(282)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(283)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [282] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [283] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(284)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(285)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(286)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [284] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(288)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [285] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(288)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [286] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [287] = {
         [sym__statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -15044,7 +15839,45 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -15055,959 +15888,1552 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-    },
-    [260] = {
-        [sym_statement_block] = ACTIONS(SHIFT(261)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(254)),
-    },
-    [261] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
-    },
-    [262] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(263)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(260)),
-    },
-    [263] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(264)),
-    },
-    [264] = {
-        [sym_statement_block] = ACTIONS(SHIFT(265)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(254)),
-    },
-    [265] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
-    },
-    [266] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [267] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(434)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(435)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [268] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(430)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [269] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(434)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(435)),
-    },
-    [270] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(430)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(431)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [271] = {
-        [sym_pair] = ACTIONS(SHIFT(425)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(425)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(426)),
-    },
-    [272] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(341)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(343)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [273] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(314)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(315)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(316)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [274] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
-    },
-    [275] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(298)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(299)),
-    },
-    [276] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(296)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [277] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(295)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [278] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(279)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [279] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-    },
-    [280] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-    },
-    [281] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(289)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(290)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(291)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
-    },
-    [282] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(286)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(287)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
-    },
-    [283] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(285)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [284] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
-    },
-    [285] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
-    },
-    [286] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(288)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
-    },
-    [287] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(288)),
     },
     [288] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
     },
     [289] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_statement_block] = ACTIONS(SHIFT(290)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(283)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(293)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [290] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(292)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(293)),
     },
     [291] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(281)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
     },
     [292] = {
+        [sym_statement_block] = ACTIONS(SHIFT(293)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(283)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(294)),
     },
     [293] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
     },
     [294] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
     },
     [295] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(462)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(463)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [296] = {
-        [sym_arguments] = ACTIONS(SHIFT(297)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(308)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
     },
     [297] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(462)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(463)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
     },
     [298] = {
+        [sym_pair] = ACTIONS(SHIFT(457)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(457)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(458)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(310)),
     },
     [299] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(300)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(373)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(375)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(301)),
     },
     [300] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(362)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(363)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(364)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(308)),
     },
     [301] = {
-        [sym_statement_block] = ACTIONS(SHIFT(302)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(303)),
     },
     [302] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(346)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(347)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [303] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(344)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [304] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(343)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [305] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(342)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [306] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(308)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(309)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [307] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(341)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [308] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(340)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [309] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(310)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [310] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [311] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [312] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(334)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(335)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(336)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [313] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(331)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(332)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [314] = {
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(330)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [315] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(327)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [316] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(326)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [317] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(325)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [318] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [319] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(324)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [320] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(323)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [321] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(322)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [322] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [323] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [324] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [325] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [326] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [327] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(328)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [328] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(329)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [329] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [330] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [331] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(333)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [332] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(333)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [333] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [334] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(337)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(338)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [335] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(337)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(338)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [336] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [337] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(339)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [338] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [339] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [340] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [341] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [342] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [343] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [344] = {
+        [sym_arguments] = ACTIONS(SHIFT(345)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [345] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [346] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(359)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(360)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [347] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(348)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [348] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(349)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(350)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [349] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(357)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [350] = {
+        [sym_statement_block] = ACTIONS(SHIFT(351)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(352)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [351] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [352] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -16022,1639 +17448,1743 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(304)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(353)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(354)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(355)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(305)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(306)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [304] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(307)),
-    },
-    [305] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(307)),
-    },
-    [306] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-    },
-    [307] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [308] = {
-        [sym_statement_block] = ACTIONS(SHIFT(309)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(303)),
-    },
-    [309] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
-    },
-    [310] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(311)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(308)),
-    },
-    [311] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(312)),
-    },
-    [312] = {
-        [sym_statement_block] = ACTIONS(SHIFT(313)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(303)),
-    },
-    [313] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
-    },
-    [314] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(317)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(319)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [315] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(317)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(319)),
-    },
-    [316] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
-    },
-    [317] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(339)),
-    },
-    [318] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(320)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(321)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [319] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
-    },
-    [320] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(322)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [321] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(322)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
-    },
-    [322] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3)),
-    },
-    [323] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(338)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [324] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(335)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
-    },
-    [325] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(334)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [326] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(333)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [327] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(332)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [328] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(331)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [329] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(330)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [330] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-    },
-    [331] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [332] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [333] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [334] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [335] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(336)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [336] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(337)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [337] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [338] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [339] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
-    },
-    [340] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [341] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(424)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [342] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(420)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [343] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(424)),
-    },
-    [344] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(420)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(421)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [345] = {
-        [sym_pair] = ACTIONS(SHIFT(412)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(412)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(413)),
-    },
-    [346] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(393)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(394)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [347] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(387)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(388)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(389)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [348] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(371)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(372)),
-    },
-    [349] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(369)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [350] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(368)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [351] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(352)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [352] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
     },
     [353] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(356)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
     },
     [354] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(362)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(363)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(356)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(364)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [355] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(359)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(360)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [356] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(358)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [357] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_statement_block] = ACTIONS(SHIFT(358)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(352)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
     },
     [358] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
     },
     [359] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(350)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(361)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [360] = {
+        [sym_statement_block] = ACTIONS(SHIFT(361)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(352)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(361)),
     },
     [361] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
     },
     [362] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(365)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(367)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(365)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(366)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [363] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(365)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(367)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(365)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(366)),
     },
     [364] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
     },
     [365] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(371)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(367)),
     },
     [366] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(368)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(369)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
     },
     [367] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
     },
     [368] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(370)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [369] = {
-        [sym_arguments] = ACTIONS(SHIFT(370)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(370)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
     },
     [370] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
     },
     [371] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(383)),
     },
     [372] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(373)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(374)),
     },
     [373] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(456)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(381)),
     },
     [374] = {
-        [sym_statement_block] = ACTIONS(SHIFT(375)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(385)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(376)),
     },
     [375] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(456)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [376] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym_pair] = ACTIONS(SHIFT(448)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(448)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(449)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [377] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(445)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(446)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [378] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(439)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(440)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(441)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [379] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(423)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(424)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [380] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(421)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [381] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(420)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [382] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(419)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [383] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(385)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(386)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [384] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(418)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [385] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(417)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [386] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(387)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [387] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [388] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [389] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(411)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(412)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(413)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [390] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(408)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(409)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [391] = {
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(407)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [392] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(404)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [393] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(403)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [394] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(402)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [395] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [396] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(401)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [397] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(400)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [398] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(399)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [399] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [400] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [401] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [402] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [403] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [404] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(405)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [405] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(406)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [406] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [407] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [408] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(410)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [409] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(410)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [410] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [411] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(414)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(415)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [412] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(414)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(415)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [413] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [414] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(416)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [415] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [416] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [417] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [418] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [419] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [420] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [421] = {
+        [sym_arguments] = ACTIONS(SHIFT(422)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [422] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [423] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(436)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(437)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [424] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(425)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [425] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(426)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(427)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [426] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(434)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [427] = {
+        [sym_statement_block] = ACTIONS(SHIFT(428)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(429)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [428] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [429] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -17669,1448 +19199,729 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(377)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(430)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(431)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(432)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(378)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(379)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [377] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(380)),
-    },
-    [378] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(380)),
-    },
-    [379] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-    },
-    [380] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [381] = {
-        [sym_statement_block] = ACTIONS(SHIFT(382)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(376)),
-    },
-    [382] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
-    },
-    [383] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(384)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(381)),
-    },
-    [384] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(385)),
-    },
-    [385] = {
-        [sym_statement_block] = ACTIONS(SHIFT(386)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(376)),
-    },
-    [386] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
-    },
-    [387] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(390)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(391)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [388] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(390)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(391)),
-    },
-    [389] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
-    },
-    [390] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(392)),
-    },
-    [391] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
-    },
-    [392] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
-    },
-    [393] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(395)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [394] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(395)),
-    },
-    [395] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-    },
-    [396] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(411)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [397] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(408)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
-    },
-    [398] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(407)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [399] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(406)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [400] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(405)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [401] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(404)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [402] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(403)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [403] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-    },
-    [404] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [405] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [406] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [407] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [408] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(409)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [409] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(410)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [410] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [411] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [412] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(414)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(416)),
-    },
-    [413] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-    },
-    [414] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(419)),
-    },
-    [415] = {
-        [sym_pair] = ACTIONS(SHIFT(417)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(417)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [416] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
-    },
-    [417] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(418)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 2)),
-    },
-    [418] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 3)),
-    },
-    [419] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
-    },
-    [420] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(423)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [421] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(422)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [422] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [423] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [424] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-    },
-    [425] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(427)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(428)),
-    },
-    [426] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-    },
-    [427] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(429)),
-    },
-    [428] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
-    },
-    [429] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [430] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(433)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(433)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
     },
     [431] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(432)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(433)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [432] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [433] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [434] = {
+        [sym_statement_block] = ACTIONS(SHIFT(435)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(429)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(436)),
     },
     [435] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [436] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(427)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [437] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_statement_block] = ACTIONS(SHIFT(438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(429)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(439)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [438] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(439)),
     },
     [439] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(442)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(443)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
     },
     [440] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(442)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(443)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(442)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(443)),
     },
     [441] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
     },
     [442] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(444)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(444)),
     },
     [443] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [444] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [445] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(447)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [446] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(447)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [447] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [448] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(450)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(452)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [449] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [450] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(455)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [451] = {
+        [sym_pair] = ACTIONS(SHIFT(453)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(453)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [452] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [453] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(454)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [454] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [455] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [456] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [457] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(459)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(460)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [458] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [459] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(461)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [460] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [461] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [462] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(464)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [463] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [464] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [465] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(467)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [466] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(467)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [467] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [468] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(470)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(471)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [469] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [470] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(472)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [471] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [472] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [473] = {
         [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -19142,7 +19953,48 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -19153,177 +20005,136 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
     },
-    [446] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(449)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(450)),
+    [474] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(477)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(478)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
-    },
-    [447] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(448)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [448] = {
+    [475] = {
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(476)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [476] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
     },
-    [449] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+    [477] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(479)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(451)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
-    [450] = {
+    [478] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(479)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(451)),
     },
-    [451] = {
+    [479] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
     },
-    [452] = {
+    [480] = {
         [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -19354,7 +20165,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -19365,76 +20196,56 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
     },
-    [453] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [481] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(483)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(455)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(455)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT(483)),
     },
-    [454] = {
+    [482] = {
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
     },
-    [455] = {
+    [483] = {
         [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -19466,7 +20277,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -19477,83 +20324,82 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
     },
-    [456] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(474)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(475)),
+    [484] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(500)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(501)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(502)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(476)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
-    [457] = {
+    [485] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(497)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [486] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(473)),
+        [sym__expression] = ACTIONS(SHIFT(496)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -19568,62 +20414,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [458] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(470)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
-    },
-    [459] = {
+    [487] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(469)),
+        [sym__expression] = ACTIONS(SHIFT(495)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -19638,86 +20449,51 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [460] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(468)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [461] = {
+    [488] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
     },
-    [462] = {
+    [489] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(467)),
+        [sym__expression] = ACTIONS(SHIFT(494)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -19732,27 +20508,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [463] = {
+    [490] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(466)),
+        [sym__expression] = ACTIONS(SHIFT(493)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -19767,27 +20543,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [464] = {
+    [491] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(465)),
+        [sym__expression] = ACTIONS(SHIFT(492)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -19802,171 +20578,171 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [465] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [492] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
     },
-    [466] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [493] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
-    [467] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [494] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
-    [468] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [495] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
-    [469] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [496] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
-    [470] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+    [497] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(498)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(471)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
-    [471] = {
+    [498] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(472)),
+        [sym__expression] = ACTIONS(SHIFT(499)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -19981,207 +20757,183 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [472] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [499] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
-    [473] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [474] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+    [500] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(503)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(504)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(477)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(478)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
-    [475] = {
+    [501] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(503)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(504)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(477)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(478)),
     },
-    [476] = {
+    [502] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
     },
-    [477] = {
+    [503] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(505)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(479)),
     },
-    [478] = {
+    [504] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
     },
-    [479] = {
+    [505] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
     },
-    [480] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [506] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(508)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(482)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(482)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT(508)),
     },
-    [481] = {
+    [507] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -20212,7 +20964,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -20223,28 +20995,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
     },
-    [482] = {
+    [508] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -20276,7 +21028,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -20287,44 +21075,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
     },
-    [483] = {
+    [509] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -20339,8 +21091,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_catch] = ACTIONS(SHIFT(489)),
-        [sym_finally] = ACTIONS(SHIFT(490)),
+        [sym_catch] = ACTIONS(SHIFT(515)),
+        [sym_finally] = ACTIONS(SHIFT(516)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_object] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -20357,7 +21109,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_catch] = ACTIONS(SHIFT(517)),
+        [aux_sym_finally] = ACTIONS(SHIFT(518)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -20368,45 +21141,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_catch] = ACTIONS(SHIFT(491)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(492)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
     },
-    [484] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [510] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -20421,49 +21173,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(485)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(511)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(512)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(513)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(486)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(487)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [485] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(488)),
-    },
-    [486] = {
+    [511] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(514)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(488)),
     },
-    [487] = {
+    [512] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(514)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [513] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -20496,7 +21248,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -20507,95 +21280,74 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [488] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [514] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
-    [489] = {
+    [515] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -20610,7 +21362,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_finally] = ACTIONS(SHIFT(508)),
+        [sym_finally] = ACTIONS(SHIFT(534)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_object] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -20627,7 +21379,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_finally] = ACTIONS(SHIFT(518)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -20638,28 +21410,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(492)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
-    [490] = {
+    [516] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -20690,7 +21442,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -20701,38 +21472,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
-    [491] = {
+    [517] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(525)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(499)),
     },
-    [492] = {
-        [sym_statement_block] = ACTIONS(SHIFT(493)),
+    [518] = {
+        [sym_statement_block] = ACTIONS(SHIFT(519)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(520)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(494)),
     },
-    [493] = {
+    [519] = {
         [sym__statement] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -20763,7 +21515,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -20774,43 +21545,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
     },
-    [494] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [520] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -20825,49 +21577,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(495)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(521)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(522)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(523)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(496)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(497)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [495] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(498)),
-    },
-    [496] = {
+    [521] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(524)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(498)),
     },
-    [497] = {
+    [522] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(524)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [523] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -20898,7 +21650,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -20909,106 +21680,87 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [498] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [524] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [499] = {
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(500)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(500)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [500] = {
+    [525] = {
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(526)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(526)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [526] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(527)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(501)),
     },
-    [501] = {
-        [sym_statement_block] = ACTIONS(SHIFT(502)),
+    [527] = {
+        [sym_statement_block] = ACTIONS(SHIFT(528)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(529)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(503)),
     },
-    [502] = {
+    [528] = {
         [sym__statement] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -21040,7 +21792,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -21051,44 +21823,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
     },
-    [503] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [529] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -21103,49 +21855,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(504)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(530)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(531)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(532)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(505)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(506)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [504] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(507)),
-    },
-    [505] = {
+    [530] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(533)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(507)),
     },
-    [506] = {
+    [531] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(533)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [532] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -21177,7 +21929,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -21188,92 +21960,72 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [507] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [533] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
-    [508] = {
+    [534] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -21304,7 +22056,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -21315,43 +22086,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
     },
-    [509] = {
-        [sym__statement] = ACTIONS(SHIFT(514)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [535] = {
+        [sym__statement] = ACTIONS(SHIFT(540)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -21366,101 +22118,101 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [510] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(511)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(512)),
+    [536] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(537)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(538)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
-    [511] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [537] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(539)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(513)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [512] = {
+    [538] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(539)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(513)),
     },
-    [513] = {
+    [539] = {
         [sym__statement] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym__paren_expression, 3)),
@@ -21492,6 +22244,23 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym__paren_expression, 3)),
@@ -21502,25 +22271,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_false] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
     },
-    [514] = {
+    [540] = {
         [sym__statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -21551,7 +22303,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -21562,6073 +22333,3262 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
-    },
-    [515] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-    },
-    [516] = {
-        [sym_var_declaration] = ACTIONS(SHIFT(517)),
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(519)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(521)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(517)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(522)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [517] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(792)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(793)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(794)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [518] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [519] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(777)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
-    },
-    [520] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [521] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(694)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [522] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(600)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(600)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(601)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [523] = {
-        [sym_pair] = ACTIONS(SHIFT(595)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(595)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(596)),
-    },
-    [524] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(592)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(593)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [525] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(586)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(587)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(588)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [526] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(570)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(571)),
-    },
-    [527] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(568)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [528] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(567)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [529] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(530)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [530] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-    },
-    [531] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [532] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(566)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [533] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(565)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [534] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(535)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [535] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
-    },
-    [536] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-    },
-    [537] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(559)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(560)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(561)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
-    },
-    [538] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(556)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(557)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
-    },
-    [539] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(555)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [540] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(552)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [541] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(551)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [542] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(550)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_var_declaration] = ACTIONS(SHIFT(543)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(545)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(543)),
+        [aux_sym_var] = ACTIONS(SHIFT(547)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(555)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [543] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(818)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(819)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(820)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
     },
     [544] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(549)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [545] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(548)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(803)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [546] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(547)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [547] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_var_assignment] = ACTIONS(SHIFT(709)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(709)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(710)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
     },
     [548] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_pair] = ACTIONS(SHIFT(704)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(704)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(705)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [549] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(701)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(702)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [550] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(695)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(696)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(697)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [551] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(679)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(680)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [552] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(677)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(553)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
     [553] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(554)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(676)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [554] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(675)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [555] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(556)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
     },
     [556] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(594)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(558)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [557] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(592)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(558)),
     },
     [558] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(559)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
     },
     [559] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(562)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(563)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [560] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(562)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(563)),
     },
     [561] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(562)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
     },
     [562] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(564)),
     },
     [563] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
     },
     [564] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(576)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(577)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(578)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
     },
     [565] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(573)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(574)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [566] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(572)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
     },
     [567] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [568] = {
-        [sym_arguments] = ACTIONS(SHIFT(569)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(571)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
     },
     [569] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(570)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
     },
     [570] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(582)),
     },
     [571] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(572)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(573)),
     },
     [572] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(580)),
     },
     [573] = {
-        [sym_statement_block] = ACTIONS(SHIFT(574)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(575)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(575)),
     },
     [574] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(575)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [575] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(576)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(577)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(578)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [576] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(579)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(580)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(579)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [577] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(579)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(580)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(579)),
     },
     [578] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [579] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(581)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [580] = {
-        [sym_statement_block] = ACTIONS(SHIFT(581)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(575)),
     },
     [581] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
     },
     [582] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(583)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(589)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(580)),
     },
     [583] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(588)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(584)),
     },
     [584] = {
-        [sym_statement_block] = ACTIONS(SHIFT(585)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(587)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(575)),
     },
     [585] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(586)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
     },
     [586] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(589)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(590)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [587] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(589)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(590)),
     },
     [588] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [589] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(590)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(591)),
     },
     [590] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(591)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [591] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [592] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(594)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [593] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(594)),
     },
     [594] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(673)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
     },
     [595] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(605)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(597)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(598)),
     },
     [596] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_pair] = ACTIONS(SHIFT(668)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(668)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(669)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
     },
     [597] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(665)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(666)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(599)),
     },
     [598] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(659)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(660)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(661)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [599] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(643)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(644)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [600] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(641)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(602)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(603)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(602)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [601] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(640)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(602)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(603)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(602)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(605)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [602] = {
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(639)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
     },
     [603] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(604)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(605)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(606)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(693)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(693)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [604] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(690)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(690)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(638)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(691)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [605] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(687)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(637)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [606] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(608)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(607)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [607] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(604)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(612)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(613)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(614)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_LT] = ACTIONS(SHIFT(618)),
+        [aux_sym_GT] = ACTIONS(SHIFT(618)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(604)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [608] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(667)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(671)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(672)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(673)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(667)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [609] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(631)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(632)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(633)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(668)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [610] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(628)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(629)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(667)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(668)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(669)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [611] = {
-        [sym_pair] = ACTIONS(SHIFT(662)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(662)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
+        [sym_identifier] = ACTIONS(SHIFT(627)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(663)),
     },
     [612] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(659)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(660)),
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(624)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [613] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(653)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(654)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(623)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(655)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
     },
     [614] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(622)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(637)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(638)),
     },
     [615] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(635)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [616] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(634)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(621)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [617] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(618)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(620)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [618] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(619)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [619] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [620] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(628)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(629)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(630)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [621] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(625)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(626)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [622] = {
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(604)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_LT] = ACTIONS(SHIFT(618)),
+        [aux_sym_GT] = ACTIONS(SHIFT(618)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(604)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(624)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [623] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(604)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(614)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_LT] = ACTIONS(SHIFT(618)),
+        [aux_sym_GT] = ACTIONS(SHIFT(618)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(604)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [624] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(625)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [625] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(626)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(627)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [626] = {
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_in] = ACTIONS(SHIFT(604)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(612)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(613)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(614)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_LT] = ACTIONS(SHIFT(618)),
+        [aux_sym_GT] = ACTIONS(SHIFT(618)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(604)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(627)),
     },
     [627] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [628] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(630)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(631)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(632)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [629] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(630)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(631)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(632)),
     },
     [630] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [631] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(634)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(635)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(633)),
     },
     [632] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(634)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(635)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [633] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [634] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(636)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [635] = {
-        [sym_arguments] = ACTIONS(SHIFT(636)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [636] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [637] = {
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_in] = ACTIONS(SHIFT(604)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(612)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(613)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(614)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(618)),
+        [aux_sym_LT] = ACTIONS(SHIFT(618)),
+        [aux_sym_GT] = ACTIONS(SHIFT(618)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(604)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(649)),
     },
     [638] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(639)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(640)),
     },
     [639] = {
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(647)),
     },
     [640] = {
-        [sym_statement_block] = ACTIONS(SHIFT(641)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(642)),
     },
     [641] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [sym_arguments] = ACTIONS(SHIFT(642)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [642] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(643)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(644)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(645)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [643] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(656)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(657)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(646)),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [644] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(645)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(646)),
     },
     [645] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_formal_parameters] = ACTIONS(SHIFT(646)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(647)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [646] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(654)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [647] = {
         [sym_statement_block] = ACTIONS(SHIFT(648)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(649)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(642)),
     },
     [648] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [649] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(650)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(650)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(651)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(652)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(647)),
     },
     [650] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(653)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(651)),
     },
     [651] = {
-        [sym_statement_block] = ACTIONS(SHIFT(652)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(653)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(642)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [652] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [653] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(656)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(657)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [654] = {
+        [sym_statement_block] = ACTIONS(SHIFT(655)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(649)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(656)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(657)),
     },
     [655] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [656] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(647)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(658)),
     },
     [657] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym_statement_block] = ACTIONS(SHIFT(658)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(649)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [658] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [659] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(662)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(663)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(661)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [660] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(662)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(663)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(661)),
     },
     [661] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [662] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(664)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(664)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(665)),
     },
     [663] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [664] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(666)),
     },
     [665] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(667)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [666] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(667)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [667] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(686)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [668] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(685)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(670)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(671)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [669] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(670)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [670] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(672)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(667)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(671)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(672)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(673)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(667)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [671] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(682)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [672] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(681)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [673] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(680)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
+        [sym__statement] = ACTIONS(SHIFT(674)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
     },
     [674] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(679)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
-    },
-    [675] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(678)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
-    },
-    [676] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(677)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
-    },
-    [677] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-    },
-    [678] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [679] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [680] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(667)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(667)),
-    },
-    [681] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(667)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(673)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(667)),
-    },
-    [682] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(683)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [683] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(607)),
-        [sym__expression] = ACTIONS(SHIFT(684)),
-        [sym_object] = ACTIONS(SHIFT(607)),
-        [sym_array] = ACTIONS(SHIFT(607)),
-        [sym_function_expression] = ACTIONS(SHIFT(607)),
-        [sym_function_call] = ACTIONS(SHIFT(607)),
-        [sym_constructor_call] = ACTIONS(SHIFT(607)),
-        [sym_member_access] = ACTIONS(SHIFT(609)),
-        [sym_subscript_access] = ACTIONS(SHIFT(609)),
-        [sym_assignment] = ACTIONS(SHIFT(607)),
-        [sym_math_assignment] = ACTIONS(SHIFT(607)),
-        [sym_ternary] = ACTIONS(SHIFT(607)),
-        [sym_bool_op] = ACTIONS(SHIFT(607)),
-        [sym_math_op] = ACTIONS(SHIFT(607)),
-        [sym_rel_op] = ACTIONS(SHIFT(607)),
-        [sym_type_op] = ACTIONS(SHIFT(607)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(607)),
-        [sym_regex] = ACTIONS(SHIFT(607)),
-        [sym_number] = ACTIONS(SHIFT(607)),
-        [sym_identifier] = ACTIONS(SHIFT(610)),
-        [sym_null] = ACTIONS(SHIFT(607)),
-        [sym_undefined] = ACTIONS(SHIFT(607)),
-        [sym_true] = ACTIONS(SHIFT(607)),
-        [sym_false] = ACTIONS(SHIFT(607)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(611)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(612)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(613)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(614)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(615)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(616)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(617)),
-    },
-    [684] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(667)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(671)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(672)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(673)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(667)),
-    },
-    [685] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(667)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(671)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(672)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(673)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(676)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(667)),
-    },
-    [686] = {
-        [sym_arguments] = ACTIONS(SHIFT(619)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(620)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(621)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(622)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(623)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(674)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(675)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [687] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(688)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [688] = {
-        [sym__statement] = ACTIONS(SHIFT(689)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [689] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-    },
-    [690] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(692)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-    },
-    [691] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(692)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
-    },
-    [692] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 3)),
-    },
-    [693] = {
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-    },
-    [694] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(696)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [695] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [696] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(775)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [697] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(756)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [698] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(755)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(756)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(757)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [699] = {
-        [sym_pair] = ACTIONS(SHIFT(750)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(750)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(30)),
-        [sym_identifier] = ACTIONS(SHIFT(30)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(751)),
-    },
-    [700] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(747)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(748)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [701] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(266)),
-        [sym__expression] = ACTIONS(SHIFT(741)),
-        [sym_object] = ACTIONS(SHIFT(266)),
-        [sym_array] = ACTIONS(SHIFT(266)),
-        [sym_function_expression] = ACTIONS(SHIFT(266)),
-        [sym_function_call] = ACTIONS(SHIFT(266)),
-        [sym_constructor_call] = ACTIONS(SHIFT(266)),
-        [sym_member_access] = ACTIONS(SHIFT(268)),
-        [sym_subscript_access] = ACTIONS(SHIFT(268)),
-        [sym_assignment] = ACTIONS(SHIFT(266)),
-        [sym_math_assignment] = ACTIONS(SHIFT(266)),
-        [sym_ternary] = ACTIONS(SHIFT(266)),
-        [sym_bool_op] = ACTIONS(SHIFT(266)),
-        [sym_math_op] = ACTIONS(SHIFT(266)),
-        [sym_rel_op] = ACTIONS(SHIFT(266)),
-        [sym_type_op] = ACTIONS(SHIFT(266)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(742)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(266)),
-        [sym_regex] = ACTIONS(SHIFT(266)),
-        [sym_number] = ACTIONS(SHIFT(266)),
-        [sym_identifier] = ACTIONS(SHIFT(270)),
-        [sym_null] = ACTIONS(SHIFT(266)),
-        [sym_undefined] = ACTIONS(SHIFT(266)),
-        [sym_true] = ACTIONS(SHIFT(266)),
-        [sym_false] = ACTIONS(SHIFT(266)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(271)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(272)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(273)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(743)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(275)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(276)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(277)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(278)),
-    },
-    [702] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(725)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(726)),
-    },
-    [703] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(723)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [704] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(722)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [705] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(706)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [706] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
-    },
-    [707] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
-    },
-    [708] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(716)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(717)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(718)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
-    },
-    [709] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(713)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(714)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
-    },
-    [710] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(712)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [711] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
-    },
-    [712] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
-    },
-    [713] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(715)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
-    },
-    [714] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(715)),
-    },
-    [715] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-    },
-    [716] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(719)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(720)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
-    },
-    [717] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(719)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(720)),
-    },
-    [718] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
-    },
-    [719] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(721)),
-    },
-    [720] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
-    },
-    [721] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
-    },
-    [722] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-    },
-    [723] = {
-        [sym_arguments] = ACTIONS(SHIFT(724)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-    },
-    [724] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-    },
-    [725] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(737)),
-    },
-    [726] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(727)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(728)),
-    },
-    [727] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(735)),
-    },
-    [728] = {
-        [sym_statement_block] = ACTIONS(SHIFT(729)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(730)),
-    },
-    [729] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
-    },
-    [730] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(731)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(732)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(733)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [731] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(734)),
-    },
-    [732] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(734)),
-    },
-    [733] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-    },
-    [734] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [735] = {
-        [sym_statement_block] = ACTIONS(SHIFT(736)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(730)),
-    },
-    [736] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
-    },
-    [737] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(738)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(735)),
-    },
-    [738] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(739)),
-    },
-    [739] = {
-        [sym_statement_block] = ACTIONS(SHIFT(740)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(730)),
-    },
-    [740] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
-    },
-    [741] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(744)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(745)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [742] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(744)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(745)),
-    },
-    [743] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
-    },
-    [744] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(746)),
-    },
-    [745] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
-    },
-    [746] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
-    },
-    [747] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(749)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [748] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(749)),
-    },
-    [749] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-    },
-    [750] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(752)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(753)),
-    },
-    [751] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-    },
-    [752] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(754)),
-    },
-    [753] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
-    },
-    [754] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
-    },
-    [755] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(774)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [756] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(773)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [757] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(758)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [758] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(755)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(759)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(760)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(761)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(755)),
-    },
-    [759] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(770)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
-    },
-    [760] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(769)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [761] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(768)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [762] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(767)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [763] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(766)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [764] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(765)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [765] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-    },
-    [766] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [767] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-    },
-    [768] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(755)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(755)),
-    },
-    [769] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(755)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(761)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(755)),
-    },
-    [770] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(771)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
-    },
-    [771] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(772)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [772] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(755)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(759)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(760)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(761)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(755)),
-    },
-    [773] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(755)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(759)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(760)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(761)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(764)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(755)),
-    },
-    [774] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [775] = {
-        [sym__statement] = ACTIONS(SHIFT(776)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [776] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
@@ -27659,7 +25619,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
@@ -27670,702 +25649,2637 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+    },
+    [675] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [676] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [677] = {
+        [sym_arguments] = ACTIONS(SHIFT(678)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [678] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [679] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(692)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(693)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [680] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(681)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [681] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(682)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(683)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [682] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(690)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [683] = {
+        [sym_statement_block] = ACTIONS(SHIFT(684)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(685)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [684] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [685] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(686)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(687)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(688)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [686] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(689)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [687] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(689)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [688] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [689] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [690] = {
+        [sym_statement_block] = ACTIONS(SHIFT(691)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(685)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [691] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [692] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(683)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [693] = {
+        [sym_statement_block] = ACTIONS(SHIFT(694)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(685)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [694] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [695] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(698)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(699)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [696] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(698)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(699)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [697] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [698] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(700)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [699] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [700] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [701] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(703)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [702] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(703)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [703] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [704] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(706)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(707)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [705] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [706] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(708)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [707] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [708] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [709] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(711)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(712)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(712)),
+    },
+    [710] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(711)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(712)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_in] = ACTIONS(SHIFT(714)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(712)),
+    },
+    [711] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(802)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(802)),
+    },
+    [712] = {
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [713] = {
+        [sym_var_assignment] = ACTIONS(SHIFT(799)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(799)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(800)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [714] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(796)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [715] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(717)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [716] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
+    },
+    [717] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(SHIFT(727)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(735)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(736)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(737)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_LT] = ACTIONS(SHIFT(741)),
+        [aux_sym_GT] = ACTIONS(SHIFT(741)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(727)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_var_assignment, 3)),
+    },
+    [718] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(728)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
+    },
+    [719] = {
+        [sym_pair] = ACTIONS(SHIFT(791)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(791)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(792)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(34)),
+        [sym_identifier] = ACTIONS(SHIFT(34)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [720] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(788)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(789)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [721] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(294)),
+        [sym__expression] = ACTIONS(SHIFT(782)),
+        [sym_object] = ACTIONS(SHIFT(294)),
+        [sym_array] = ACTIONS(SHIFT(294)),
+        [sym_function_expression] = ACTIONS(SHIFT(294)),
+        [sym_function_call] = ACTIONS(SHIFT(294)),
+        [sym_constructor_call] = ACTIONS(SHIFT(294)),
+        [sym_member_access] = ACTIONS(SHIFT(296)),
+        [sym_subscript_access] = ACTIONS(SHIFT(296)),
+        [sym_assignment] = ACTIONS(SHIFT(294)),
+        [sym_math_assignment] = ACTIONS(SHIFT(294)),
+        [sym_ternary] = ACTIONS(SHIFT(294)),
+        [sym_bool_op] = ACTIONS(SHIFT(294)),
+        [sym_math_op] = ACTIONS(SHIFT(294)),
+        [sym_rel_op] = ACTIONS(SHIFT(294)),
+        [sym_type_op] = ACTIONS(SHIFT(294)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(783)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(298)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(299)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(300)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(784)),
+        [aux_sym_function] = ACTIONS(SHIFT(302)),
+        [aux_sym_new] = ACTIONS(SHIFT(303)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(304)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(305)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(294)),
+        [sym_regex] = ACTIONS(SHIFT(294)),
+        [sym_number] = ACTIONS(SHIFT(294)),
+        [sym_identifier] = ACTIONS(SHIFT(306)),
+        [sym_null] = ACTIONS(SHIFT(294)),
+        [sym_undefined] = ACTIONS(SHIFT(294)),
+        [sym_true] = ACTIONS(SHIFT(294)),
+        [sym_false] = ACTIONS(SHIFT(294)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [722] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(766)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(767)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [723] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(764)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [724] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(763)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [725] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(762)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [726] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(727)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(728)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(729)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+    },
+    [727] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(761)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [728] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(760)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [729] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(730)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [730] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(SHIFT(727)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(735)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(736)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(737)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_LT] = ACTIONS(SHIFT(741)),
+        [aux_sym_GT] = ACTIONS(SHIFT(741)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(727)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
+    },
+    [731] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_function_call, 2)),
+    },
+    [732] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(141)),
+        [sym__expression] = ACTIONS(SHIFT(754)),
+        [sym_object] = ACTIONS(SHIFT(141)),
+        [sym_array] = ACTIONS(SHIFT(141)),
+        [sym_function_expression] = ACTIONS(SHIFT(141)),
+        [sym_function_call] = ACTIONS(SHIFT(141)),
+        [sym_constructor_call] = ACTIONS(SHIFT(141)),
+        [sym_member_access] = ACTIONS(SHIFT(143)),
+        [sym_subscript_access] = ACTIONS(SHIFT(143)),
+        [sym_assignment] = ACTIONS(SHIFT(141)),
+        [sym_math_assignment] = ACTIONS(SHIFT(141)),
+        [sym_ternary] = ACTIONS(SHIFT(141)),
+        [sym_bool_op] = ACTIONS(SHIFT(141)),
+        [sym_math_op] = ACTIONS(SHIFT(141)),
+        [sym_rel_op] = ACTIONS(SHIFT(141)),
+        [sym_type_op] = ACTIONS(SHIFT(141)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(755)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(146)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(756)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(148)),
+        [aux_sym_function] = ACTIONS(SHIFT(149)),
+        [aux_sym_new] = ACTIONS(SHIFT(150)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(151)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(152)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(141)),
+        [sym_regex] = ACTIONS(SHIFT(141)),
+        [sym_number] = ACTIONS(SHIFT(141)),
+        [sym_identifier] = ACTIONS(SHIFT(153)),
+        [sym_null] = ACTIONS(SHIFT(141)),
+        [sym_undefined] = ACTIONS(SHIFT(141)),
+        [sym_true] = ACTIONS(SHIFT(141)),
+        [sym_false] = ACTIONS(SHIFT(141)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [733] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(102)),
+        [sym__expression] = ACTIONS(SHIFT(751)),
+        [sym_object] = ACTIONS(SHIFT(102)),
+        [sym_array] = ACTIONS(SHIFT(102)),
+        [sym_function_expression] = ACTIONS(SHIFT(102)),
+        [sym_function_call] = ACTIONS(SHIFT(102)),
+        [sym_constructor_call] = ACTIONS(SHIFT(102)),
+        [sym_member_access] = ACTIONS(SHIFT(104)),
+        [sym_subscript_access] = ACTIONS(SHIFT(104)),
+        [sym_assignment] = ACTIONS(SHIFT(102)),
+        [sym_math_assignment] = ACTIONS(SHIFT(102)),
+        [sym_ternary] = ACTIONS(SHIFT(102)),
+        [sym_bool_op] = ACTIONS(SHIFT(102)),
+        [sym_math_op] = ACTIONS(SHIFT(102)),
+        [sym_rel_op] = ACTIONS(SHIFT(102)),
+        [sym_type_op] = ACTIONS(SHIFT(102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(752)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(106)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(107)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(108)),
+        [aux_sym_function] = ACTIONS(SHIFT(109)),
+        [aux_sym_new] = ACTIONS(SHIFT(110)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(111)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(112)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(102)),
+        [sym_regex] = ACTIONS(SHIFT(102)),
+        [sym_number] = ACTIONS(SHIFT(102)),
+        [sym_identifier] = ACTIONS(SHIFT(113)),
+        [sym_null] = ACTIONS(SHIFT(102)),
+        [sym_undefined] = ACTIONS(SHIFT(102)),
+        [sym_true] = ACTIONS(SHIFT(102)),
+        [sym_false] = ACTIONS(SHIFT(102)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [734] = {
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(750)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [735] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(747)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [736] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(746)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [737] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(745)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [738] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_math_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_math_op, 2)),
+    },
+    [739] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(744)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [740] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(743)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [741] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(742)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [742] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
+    },
+    [743] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+    },
+    [744] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
+    },
+    [745] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(SHIFT(727)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_LT] = ACTIONS(SHIFT(741)),
+        [aux_sym_GT] = ACTIONS(SHIFT(741)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(727)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+    },
+    [746] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(SHIFT(727)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(737)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_LT] = ACTIONS(SHIFT(741)),
+        [aux_sym_GT] = ACTIONS(SHIFT(741)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(727)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
+    },
+    [747] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(748)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [748] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(716)),
+        [sym__expression] = ACTIONS(SHIFT(749)),
+        [sym_object] = ACTIONS(SHIFT(716)),
+        [sym_array] = ACTIONS(SHIFT(716)),
+        [sym_function_expression] = ACTIONS(SHIFT(716)),
+        [sym_function_call] = ACTIONS(SHIFT(716)),
+        [sym_constructor_call] = ACTIONS(SHIFT(716)),
+        [sym_member_access] = ACTIONS(SHIFT(718)),
+        [sym_subscript_access] = ACTIONS(SHIFT(718)),
+        [sym_assignment] = ACTIONS(SHIFT(716)),
+        [sym_math_assignment] = ACTIONS(SHIFT(716)),
+        [sym_ternary] = ACTIONS(SHIFT(716)),
+        [sym_bool_op] = ACTIONS(SHIFT(716)),
+        [sym_math_op] = ACTIONS(SHIFT(716)),
+        [sym_rel_op] = ACTIONS(SHIFT(716)),
+        [sym_type_op] = ACTIONS(SHIFT(716)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(719)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(720)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(721)),
+        [aux_sym_function] = ACTIONS(SHIFT(722)),
+        [aux_sym_new] = ACTIONS(SHIFT(723)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(724)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(725)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(716)),
+        [sym_regex] = ACTIONS(SHIFT(716)),
+        [sym_number] = ACTIONS(SHIFT(716)),
+        [sym_identifier] = ACTIONS(SHIFT(726)),
+        [sym_null] = ACTIONS(SHIFT(716)),
+        [sym_undefined] = ACTIONS(SHIFT(716)),
+        [sym_true] = ACTIONS(SHIFT(716)),
+        [sym_false] = ACTIONS(SHIFT(716)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [749] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(SHIFT(727)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(735)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(736)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(737)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_LT] = ACTIONS(SHIFT(741)),
+        [aux_sym_GT] = ACTIONS(SHIFT(741)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(727)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+    },
+    [750] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_member_access, 3)),
+    },
+    [751] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(753)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [752] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(753)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [753] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+    },
+    [754] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(757)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(758)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [755] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(757)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(758)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [756] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 2)),
+    },
+    [757] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(759)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [758] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 3)),
+    },
+    [759] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_arguments, 4)),
+    },
+    [760] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(SHIFT(727)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(735)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(736)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(737)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(741)),
+        [aux_sym_LT] = ACTIONS(SHIFT(741)),
+        [aux_sym_GT] = ACTIONS(SHIFT(741)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(727)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+    },
+    [761] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(739)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(739)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(740)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(740)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+    },
+    [762] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+    },
+    [763] = {
+        [sym_arguments] = ACTIONS(SHIFT(731)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(738)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(738)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+    },
+    [764] = {
+        [sym_arguments] = ACTIONS(SHIFT(765)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(732)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(733)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(734)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+    },
+    [765] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+    },
+    [766] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(779)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(780)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [767] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(768)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [768] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(769)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(770)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [769] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(777)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [770] = {
+        [sym_statement_block] = ACTIONS(SHIFT(771)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(772)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [771] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 5)),
+    },
+    [772] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(773)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(774)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(775)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [773] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(776)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [774] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(776)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [775] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+    },
+    [776] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
     },
     [777] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(778)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(779)),
+        [sym_statement_block] = ACTIONS(SHIFT(778)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(772)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(780)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [778] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(787)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 6)),
     },
     [779] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(770)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(787)),
     },
     [780] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(781)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(782)),
+        [sym_statement_block] = ACTIONS(SHIFT(781)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(772)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(783)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [781] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(785)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [782] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(785)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(786)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(785)),
     },
     [783] = {
-        [sym__statement] = ACTIONS(SHIFT(784)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(785)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(786)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [784] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [785] = {
-        [sym__statement] = ACTIONS(SHIFT(786)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(787)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [786] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [787] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(788)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(789)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(785)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [788] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(790)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(790)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [789] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(790)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(790)),
     },
     [790] = {
-        [sym__statement] = ACTIONS(SHIFT(791)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+        [sym__line_break] = ACTIONS(REDUCE(sym__paren_expression, 3)),
     },
     [791] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(793)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(794)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
     },
     [792] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(780)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
     },
     [793] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(795)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(780)),
     },
     [794] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(795)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(796)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(797)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [795] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(783)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [796] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(797)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(783)),
     },
     [797] = {
         [sym__statement] = ACTIONS(SHIFT(798)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -28380,385 +28294,425 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [798] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
     },
     [799] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(801)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(804)),
+        [sym__line_break] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
     },
     [800] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(801)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(802)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(801)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
+        [sym__line_break] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 2)),
     },
     [801] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(803)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
+        [sym__line_break] = ACTIONS(REDUCE(aux_sym_var_declaration_repeat1, 3)),
     },
     [802] = {
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(803)),
     },
     [803] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(804)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(805)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(806)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
     },
     [804] = {
-        [sym_case] = ACTIONS(SHIFT(805)),
-        [sym_default] = ACTIONS(SHIFT(805)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(813)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(806)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(807)),
-        [aux_sym_STR_case] = ACTIONS(SHIFT(808)),
-        [aux_sym_STR_default] = ACTIONS(SHIFT(809)),
     },
     [805] = {
-        [sym_case] = ACTIONS(SHIFT(805)),
-        [sym_default] = ACTIONS(SHIFT(805)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(813)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1034)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_switch_statement_repeat1, 1)),
-        [aux_sym_STR_case] = ACTIONS(SHIFT(808)),
-        [aux_sym_STR_default] = ACTIONS(SHIFT(809)),
     },
     [806] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(807)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(808)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(809)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1033)),
     },
     [807] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym__expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_object] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_array] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(811)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_number] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_null] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
     },
     [808] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(1030)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(811)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [809] = {
+        [sym__statement] = ACTIONS(SHIFT(810)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(810)),
     },
     [810] = {
-        [sym__statement] = ACTIONS(SHIFT(811)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym_case] = ACTIONS(REDUCE(sym_default, 2)),
-        [sym_default] = ACTIONS(REDUCE(sym_default, 2)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
+        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(815)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_default, 2)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_default, 2)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_default, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_default, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [811] = {
-        [sym__statement] = ACTIONS(SHIFT(811)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym_case] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [sym_default] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [sym__statement] = ACTIONS(SHIFT(812)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -28773,3057 +28727,224 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1029)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [812] = {
-        [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_case] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_default] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym__expression] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_object] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_array] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_function_call] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_member_access] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_ternary] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_number] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_null] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_undefined] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
     },
     [813] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(814)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(815)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(811)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1028)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1028)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [814] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1028)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1028)),
-    },
-    [815] = {
-        [sym_case] = ACTIONS(REDUCE(sym_default, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_default, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(816)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [815] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(816)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_default, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_default, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_default, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_default, 3)),
     },
     [816] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(1023)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1023)),
+        [sym__statement] = ACTIONS(SHIFT(817)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1024)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [817] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_pair] = ACTIONS(SHIFT(29)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1020)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(1002)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(1003)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(848)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1021)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [818] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(904)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
-    },
-    [819] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(899)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(800)),
-    },
-    [820] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(863)),
-    },
-    [821] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(861)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
-    },
-    [822] = {
-        [sym_statement_block] = ACTIONS(SHIFT(835)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(836)),
-    },
-    [823] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(832)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT(833)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(833)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [824] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(830)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [825] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(829)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(829)),
-    },
-    [826] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(199)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(827)),
-        [sym_subscript_access] = ACTIONS(SHIFT(827)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [827] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(828)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(828)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [828] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-    },
-    [829] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_case] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_default] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
-    },
-    [830] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(831)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(831)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
-    },
-    [831] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-    },
-    [832] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(834)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(834)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
-    },
-    [833] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_case] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_default] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
-    },
-    [834] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
-    },
-    [835] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_catch] = ACTIONS(SHIFT(841)),
-        [sym_finally] = ACTIONS(SHIFT(842)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_catch] = ACTIONS(SHIFT(843)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(844)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
-    },
-    [836] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(837)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(838)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(839)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [837] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(840)),
-    },
-    [838] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(840)),
-    },
-    [839] = {
-        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-    },
-    [840] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [841] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_finally] = ACTIONS(SHIFT(860)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(844)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
-    },
-    [842] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
-    },
-    [843] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(851)),
-    },
-    [844] = {
-        [sym_statement_block] = ACTIONS(SHIFT(845)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(846)),
-    },
-    [845] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_case] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_default] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_finally, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_finally, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
-    },
-    [846] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(847)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(848)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(849)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [847] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(850)),
-    },
-    [848] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(850)),
-    },
-    [849] = {
-        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-    },
-    [850] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [851] = {
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(852)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(852)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [852] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(853)),
-    },
-    [853] = {
-        [sym_statement_block] = ACTIONS(SHIFT(854)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(855)),
-    },
-    [854] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_case] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_default] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym__expression] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_object] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_array] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_catch, 5)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_regex] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_number] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_null] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_true] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym_false] = ACTIONS(REDUCE(sym_catch, 5)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
-    },
-    [855] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(856)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(857)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(858)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [856] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(859)),
-    },
-    [857] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(859)),
-    },
-    [858] = {
-        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-    },
-    [859] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [860] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
-    },
-    [861] = {
-        [sym__statement] = ACTIONS(SHIFT(862)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [862] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
-    },
-    [863] = {
-        [sym_var_declaration] = ACTIONS(SHIFT(864)),
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(865)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(866)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(864)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(867)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [864] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(892)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(893)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(894)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [865] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(877)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
-    },
-    [866] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(873)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-    },
-    [867] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(600)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(600)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(868)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [868] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(602)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(603)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(602)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(869)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
-    },
-    [869] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(870)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [870] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(871)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [871] = {
-        [sym__statement] = ACTIONS(SHIFT(872)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [872] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-    },
-    [873] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(874)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [874] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(875)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [875] = {
-        [sym__statement] = ACTIONS(SHIFT(876)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [876] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-    },
-    [877] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(878)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(879)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(880)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
-    },
-    [878] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(887)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
-    },
-    [879] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(887)),
-    },
-    [880] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(881)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(882)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(883)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [881] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(885)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [882] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(885)),
-    },
-    [883] = {
-        [sym__statement] = ACTIONS(SHIFT(884)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [884] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
-    },
-    [885] = {
-        [sym__statement] = ACTIONS(SHIFT(886)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [886] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
-    },
-    [887] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(888)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(889)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(885)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [888] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(890)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [889] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(890)),
-    },
-    [890] = {
-        [sym__statement] = ACTIONS(SHIFT(891)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [891] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -31838,8 +28959,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_object] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -31856,7 +28975,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -31867,141 +29005,119 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
     },
-    [892] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+    [818] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(806)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(880)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
-    [893] = {
+    [819] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(806)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(880)),
     },
-    [894] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(895)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(896)),
+    [820] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(821)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(822)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(823)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(897)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
-    [895] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [821] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(809)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(883)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [896] = {
+    [822] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(809)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(883)),
     },
-    [897] = {
-        [sym__statement] = ACTIONS(SHIFT(898)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
+    [823] = {
+        [sym__statement] = ACTIONS(SHIFT(824)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -32016,36 +29132,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [898] = {
+    [824] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -32060,8 +29176,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_object] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -32078,7 +29192,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -32089,50 +29222,108 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
     },
-    [899] = {
+    [825] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(830)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(900)),
     },
-    [900] = {
-        [sym_case] = ACTIONS(SHIFT(805)),
-        [sym_default] = ACTIONS(SHIFT(805)),
+    [826] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(827)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(828)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [827] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(829)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(901)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(902)),
-        [aux_sym_STR_case] = ACTIONS(SHIFT(808)),
-        [aux_sym_STR_default] = ACTIONS(SHIFT(809)),
     },
-    [901] = {
+    [828] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(829)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(903)),
     },
-    [902] = {
+    [829] = {
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [830] = {
+        [sym_case] = ACTIONS(SHIFT(831)),
+        [sym_default] = ACTIONS(SHIFT(831)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(832)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(833)),
+        [aux_sym_case] = ACTIONS(SHIFT(834)),
+        [aux_sym_default] = ACTIONS(SHIFT(835)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [831] = {
+        [sym_case] = ACTIONS(SHIFT(831)),
+        [sym_default] = ACTIONS(SHIFT(831)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1056)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_switch_statement_repeat1, 1)),
+        [aux_sym_case] = ACTIONS(SHIFT(834)),
+        [aux_sym_default] = ACTIONS(SHIFT(835)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [832] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1055)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [833] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -32147,8 +29338,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_throw_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_break_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_delete_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_case] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [sym_default] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_object] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -32165,7 +29354,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -32176,113 +29384,66 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
     },
-    [903] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_case] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_default] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym__expression] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_object] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_array] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+    [834] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(67)),
+        [sym__expression] = ACTIONS(SHIFT(1052)),
+        [sym_object] = ACTIONS(SHIFT(67)),
+        [sym_array] = ACTIONS(SHIFT(67)),
+        [sym_function_expression] = ACTIONS(SHIFT(67)),
+        [sym_function_call] = ACTIONS(SHIFT(67)),
+        [sym_constructor_call] = ACTIONS(SHIFT(67)),
+        [sym_member_access] = ACTIONS(SHIFT(69)),
+        [sym_subscript_access] = ACTIONS(SHIFT(69)),
+        [sym_assignment] = ACTIONS(SHIFT(67)),
+        [sym_math_assignment] = ACTIONS(SHIFT(67)),
+        [sym_ternary] = ACTIONS(SHIFT(67)),
+        [sym_bool_op] = ACTIONS(SHIFT(67)),
+        [sym_math_op] = ACTIONS(SHIFT(67)),
+        [sym_rel_op] = ACTIONS(SHIFT(67)),
+        [sym_type_op] = ACTIONS(SHIFT(67)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(70)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(71)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(72)),
+        [aux_sym_function] = ACTIONS(SHIFT(73)),
+        [aux_sym_new] = ACTIONS(SHIFT(74)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(75)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(76)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_number] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_null] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_string] = ACTIONS(SHIFT(67)),
+        [sym_regex] = ACTIONS(SHIFT(67)),
+        [sym_number] = ACTIONS(SHIFT(67)),
+        [sym_identifier] = ACTIONS(SHIFT(77)),
+        [sym_null] = ACTIONS(SHIFT(67)),
+        [sym_undefined] = ACTIONS(SHIFT(67)),
+        [sym_true] = ACTIONS(SHIFT(67)),
+        [sym_false] = ACTIONS(SHIFT(67)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
     },
-    [904] = {
-        [sym__statement] = ACTIONS(SHIFT(905)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [835] = {
+        [aux_sym_COLON] = ACTIONS(SHIFT(836)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [836] = {
+        [sym__statement] = ACTIONS(SHIFT(837)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
+        [sym_case] = ACTIONS(REDUCE(sym_default, 2)),
+        [sym_default] = ACTIONS(REDUCE(sym_default, 2)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -32297,104 +29458,108 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(840)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_default, 2)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_default, 2)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_default, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_default, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [905] = {
-        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+    [837] = {
+        [sym__statement] = ACTIONS(SHIFT(837)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
+        [sym_case] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [sym_default] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1051)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_case] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_default] = ACTIONS(REDUCE(aux_sym_program_repeat1, 1)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(SHIFT(1018)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
     },
-    [906] = {
+    [838] = {
         [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -32427,7 +29592,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -32438,83 +29625,70 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
     },
-    [907] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [839] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1050)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1017)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1017)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT(1050)),
     },
-    [908] = {
+    [840] = {
+        [sym_case] = ACTIONS(REDUCE(sym_default, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_default, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_default, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_default, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_default, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_default, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1017)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1017)),
-    },
-    [909] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(1012)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1012)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1013)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [910] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [841] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1050)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1050)),
+    },
+    [842] = {
+        [sym_var_assignment] = ACTIONS(SHIFT(1045)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1045)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1046)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [843] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -32529,70 +29703,70 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_pair] = ACTIONS(SHIFT(29)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1001)),
+        [sym_pair] = ACTIONS(SHIFT(32)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(873)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1042)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1043)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(1002)),
+        [sym_string] = ACTIONS(SHIFT(1029)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(1003)),
+        [sym_identifier] = ACTIONS(SHIFT(1030)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(941)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1004)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [911] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(997)),
+    [844] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(930)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
     },
-    [912] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(992)),
+    [845] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(925)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(826)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(800)),
     },
-    [913] = {
+    [846] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(889)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(956)),
     },
-    [914] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(954)),
+    [847] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(887)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
     },
-    [915] = {
-        [sym_statement_block] = ACTIONS(SHIFT(928)),
+    [848] = {
+        [sym_statement_block] = ACTIONS(SHIFT(861)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(862)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(929)),
     },
-    [916] = {
+    [849] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(925)),
+        [sym__expression] = ACTIONS(SHIFT(858)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -32607,28 +29781,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(859)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT(926)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(926)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+        [sym__line_break] = ACTIONS(SHIFT(859)),
     },
-    [917] = {
+    [850] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(923)),
+        [sym__expression] = ACTIONS(SHIFT(856)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -32643,94 +29817,94 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [918] = {
+    [851] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(855)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(922)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(922)),
+        [sym__line_break] = ACTIONS(SHIFT(855)),
     },
-    [919] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(199)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(920)),
-        [sym_subscript_access] = ACTIONS(SHIFT(920)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+    [852] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(227)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(853)),
+        [sym_subscript_access] = ACTIONS(SHIFT(853)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
     },
-    [920] = {
+    [853] = {
         [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(854)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(921)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(921)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__line_break] = ACTIONS(SHIFT(854)),
     },
-    [921] = {
+    [854] = {
         [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -32764,7 +29938,51 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -32775,53 +29993,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
     },
-    [922] = {
+    [855] = {
         [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -32854,7 +30027,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -32865,56 +30061,32 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
     },
-    [923] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [856] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(857)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(924)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(924)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT(857)),
     },
-    [924] = {
+    [857] = {
         [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -32948,7 +30120,46 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -32959,72 +30170,32 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
     },
-    [925] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+    [858] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(860)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(927)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(927)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT(860)),
     },
-    [926] = {
+    [859] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -33057,7 +30228,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -33068,32 +30262,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
     },
-    [927] = {
+    [860] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -33127,7 +30297,46 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -33138,48 +30347,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
     },
-    [928] = {
+    [861] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -33196,8 +30365,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_case] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_default] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_catch] = ACTIONS(SHIFT(934)),
-        [sym_finally] = ACTIONS(SHIFT(935)),
+        [sym_catch] = ACTIONS(SHIFT(867)),
+        [sym_finally] = ACTIONS(SHIFT(868)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_object] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -33214,7 +30383,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_catch] = ACTIONS(SHIFT(869)),
+        [aux_sym_finally] = ACTIONS(SHIFT(870)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -33225,49 +30418,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_catch] = ACTIONS(SHIFT(936)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(937)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
     },
-    [929] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [862] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -33282,49 +30450,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(930)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(863)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(864)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(865)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(931)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(932)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [930] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(933)),
-    },
-    [931] = {
+    [863] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(866)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(933)),
     },
-    [932] = {
+    [864] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(866)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [865] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -33359,7 +30527,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -33370,105 +30562,79 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [933] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [866] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
-    [934] = {
+    [867] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -33485,7 +30651,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_finally] = ACTIONS(SHIFT(953)),
+        [sym_finally] = ACTIONS(SHIFT(886)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_object] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -33502,7 +30668,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_finally] = ACTIONS(SHIFT(870)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -33513,32 +30702,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(937)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
-    [935] = {
+    [868] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -33571,7 +30736,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -33582,42 +30769,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
-    [936] = {
+    [869] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(877)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(944)),
     },
-    [937] = {
-        [sym_statement_block] = ACTIONS(SHIFT(938)),
+    [870] = {
+        [sym_statement_block] = ACTIONS(SHIFT(871)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(872)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(939)),
     },
-    [938] = {
+    [871] = {
         [sym__statement] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -33650,7 +30814,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -33661,47 +30847,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
     },
-    [939] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [872] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -33716,49 +30879,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(940)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(873)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(874)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(875)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(941)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(942)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [940] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(943)),
-    },
-    [941] = {
+    [873] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(876)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(943)),
     },
-    [942] = {
+    [874] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(876)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [875] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -33791,7 +30954,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -33802,116 +30987,92 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [943] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [876] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [944] = {
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(945)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(945)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [945] = {
+    [877] = {
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(878)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(878)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [878] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(879)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(946)),
     },
-    [946] = {
-        [sym_statement_block] = ACTIONS(SHIFT(947)),
+    [879] = {
+        [sym_statement_block] = ACTIONS(SHIFT(880)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(881)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(948)),
     },
-    [947] = {
+    [880] = {
         [sym__statement] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -33945,7 +31106,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -33956,48 +31140,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
     },
-    [948] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [881] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -34012,49 +31172,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(949)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(882)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(883)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(884)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(950)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(951)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [949] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(952)),
-    },
-    [950] = {
+    [882] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(885)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(952)),
     },
-    [951] = {
+    [883] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(885)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [884] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -34088,7 +31248,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -34099,102 +31282,77 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [952] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [885] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
-    [953] = {
+    [886] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -34227,7 +31385,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -34238,47 +31418,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
     },
-    [954] = {
-        [sym__statement] = ACTIONS(SHIFT(955)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [887] = {
+        [sym__statement] = ACTIONS(SHIFT(888)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -34293,36 +31450,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [955] = {
+    [888] = {
         [sym__statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -34355,7 +31512,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -34366,250 +31545,219 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
     },
-    [956] = {
-        [sym_var_declaration] = ACTIONS(SHIFT(957)),
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(958)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+    [889] = {
+        [sym_var_declaration] = ACTIONS(SHIFT(890)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(891)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(890)),
+        [aux_sym_var] = ACTIONS(SHIFT(892)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(959)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(893)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(957)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(960)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
-    [957] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(985)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(986)),
+    [890] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(918)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(919)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(920)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(987)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
-    [958] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+    [891] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(903)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(970)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
-    [959] = {
+    [892] = {
+        [sym_var_assignment] = ACTIONS(SHIFT(709)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(709)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(898)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [893] = {
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(894)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(966)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
-    [960] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(600)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(600)),
+    [894] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(895)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(961)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [961] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(602)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(603)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(602)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(962)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
-    },
-    [962] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(963)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [963] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [895] = {
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(896)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(964)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [964] = {
-        [sym__statement] = ACTIONS(SHIFT(965)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [896] = {
+        [sym__statement] = ACTIONS(SHIFT(897)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -34624,224 +31772,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [965] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-    },
-    [966] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(967)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [967] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(968)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [968] = {
-        [sym__statement] = ACTIONS(SHIFT(969)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [969] = {
+    [897] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
@@ -34874,7 +31834,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
@@ -34885,179 +31867,92 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
     },
-    [970] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(971)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(972)),
+    [898] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(711)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(712)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_in] = ACTIONS(SHIFT(899)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(973)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
+        [sym__line_break] = ACTIONS(SHIFT(712)),
     },
-    [971] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+    [899] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(900)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [900] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(901)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(980)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
-    [972] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(980)),
-    },
-    [973] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(974)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(975)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(976)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [974] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(978)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [975] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(978)),
-    },
-    [976] = {
-        [sym__statement] = ACTIONS(SHIFT(977)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [901] = {
+        [sym__statement] = ACTIONS(SHIFT(902)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -35072,36 +31967,295 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [977] = {
+    [902] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [903] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(904)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(905)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(906)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [904] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(913)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [905] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(913)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [906] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(909)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [907] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(911)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [908] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(911)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [909] = {
+        [sym__statement] = ACTIONS(SHIFT(910)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [910] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -35134,7 +32288,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -35145,47 +32321,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
     },
-    [978] = {
-        [sym__statement] = ACTIONS(SHIFT(979)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [911] = {
+        [sym__statement] = ACTIONS(SHIFT(912)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -35200,36 +32353,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [979] = {
+    [912] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -35262,7 +32415,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -35273,113 +32448,90 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
     },
-    [980] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(981)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(982)),
+    [913] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(914)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(915)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(911)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(978)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
-    [981] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [914] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(916)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(983)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [982] = {
+    [915] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(916)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(983)),
     },
-    [983] = {
-        [sym__statement] = ACTIONS(SHIFT(984)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [916] = {
+        [sym__statement] = ACTIONS(SHIFT(917)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -35394,36 +32546,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [984] = {
+    [917] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -35456,7 +32608,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -35467,142 +32641,119 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
     },
-    [985] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+    [918] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(906)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(973)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
-    [986] = {
+    [919] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(906)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(973)),
     },
-    [987] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(988)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(989)),
+    [920] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(921)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(922)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(923)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(990)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
-    [988] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [921] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(909)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(976)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [989] = {
+    [922] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(909)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(976)),
     },
-    [990] = {
-        [sym__statement] = ACTIONS(SHIFT(991)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [923] = {
+        [sym__statement] = ACTIONS(SHIFT(924)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -35617,36 +32768,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [991] = {
+    [924] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -35679,7 +32830,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -35690,51 +32863,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
     },
-    [992] = {
+    [925] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(926)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(993)),
     },
-    [993] = {
-        [sym_case] = ACTIONS(SHIFT(805)),
-        [sym_default] = ACTIONS(SHIFT(805)),
+    [926] = {
+        [sym_case] = ACTIONS(SHIFT(831)),
+        [sym_default] = ACTIONS(SHIFT(831)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(927)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(928)),
+        [aux_sym_case] = ACTIONS(SHIFT(834)),
+        [aux_sym_default] = ACTIONS(SHIFT(835)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(994)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(995)),
-        [aux_sym_STR_case] = ACTIONS(SHIFT(808)),
-        [aux_sym_STR_default] = ACTIONS(SHIFT(809)),
     },
-    [994] = {
+    [927] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(929)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(996)),
     },
-    [995] = {
+    [928] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -35767,7 +32917,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -35778,31 +32950,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
     },
-    [996] = {
+    [929] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -35835,7 +32984,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -35846,47 +33017,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
     },
-    [997] = {
-        [sym__statement] = ACTIONS(SHIFT(998)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
+    [930] = {
+        [sym__statement] = ACTIONS(SHIFT(931)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -35901,36 +33049,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [998] = {
+    [931] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -35963,7 +33111,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_else] = ACTIONS(SHIFT(1040)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -35974,804 +33145,2993 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(SHIFT(999)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+    },
+    [932] = {
+        [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_case] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_default] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym__expression] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_object] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_array] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_function_call] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_member_access] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_ternary] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_number] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_null] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_undefined] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [933] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1039)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1039)),
+    },
+    [934] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1039)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1039)),
+    },
+    [935] = {
+        [sym_var_assignment] = ACTIONS(SHIFT(1034)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1034)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1035)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [936] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [sym_pair] = ACTIONS(SHIFT(32)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(966)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1027)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1028)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(1029)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(1030)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [937] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(1023)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [938] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(1018)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(826)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [939] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(982)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [940] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(980)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [941] = {
+        [sym_statement_block] = ACTIONS(SHIFT(954)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(955)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [942] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(951)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(952)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT(952)),
+    },
+    [943] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(949)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [944] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(948)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(948)),
+    },
+    [945] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(227)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(946)),
+        [sym_subscript_access] = ACTIONS(SHIFT(946)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [946] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(947)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(947)),
+    },
+    [947] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_case] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [948] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_case] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_default] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [949] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(950)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(950)),
+    },
+    [950] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_case] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [951] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(953)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(953)),
+    },
+    [952] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_case] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_default] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [953] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_case] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [954] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_catch] = ACTIONS(SHIFT(960)),
+        [sym_finally] = ACTIONS(SHIFT(961)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_catch] = ACTIONS(SHIFT(962)),
+        [aux_sym_finally] = ACTIONS(SHIFT(963)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [955] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(956)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(957)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(958)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [956] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(959)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [957] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(959)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [958] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [959] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [960] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_finally] = ACTIONS(SHIFT(979)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_finally] = ACTIONS(SHIFT(963)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [961] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [962] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(970)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [963] = {
+        [sym_statement_block] = ACTIONS(SHIFT(964)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(965)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [964] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_case] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_default] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_finally, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [965] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(966)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(967)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(968)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [966] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(969)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [967] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(969)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [968] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [969] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [970] = {
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(971)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(971)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [971] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(972)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [972] = {
+        [sym_statement_block] = ACTIONS(SHIFT(973)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(974)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [973] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_case] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_default] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym__expression] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_object] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_array] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_regex] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_number] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_null] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_true] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym_false] = ACTIONS(REDUCE(sym_catch, 5)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [974] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(975)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(976)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(977)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [975] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(978)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [976] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(978)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [977] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [978] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [979] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_case] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_default] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [980] = {
+        [sym__statement] = ACTIONS(SHIFT(981)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [981] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_case] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [982] = {
+        [sym_var_declaration] = ACTIONS(SHIFT(983)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(984)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(983)),
+        [aux_sym_var] = ACTIONS(SHIFT(985)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(986)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [983] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(1011)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1012)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1013)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [984] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(996)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [985] = {
+        [sym_var_assignment] = ACTIONS(SHIFT(709)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(709)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(991)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [986] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(987)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [987] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(988)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [988] = {
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(989)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [989] = {
+        [sym__statement] = ACTIONS(SHIFT(990)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [990] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [991] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(711)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(712)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_in] = ACTIONS(SHIFT(992)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(712)),
+    },
+    [992] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(993)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [993] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(994)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [994] = {
+        [sym__statement] = ACTIONS(SHIFT(995)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [995] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [996] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(997)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(998)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(999)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [997] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1006)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [998] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1006)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [999] = {
-        [sym__statement] = ACTIONS(SHIFT(1000)),
-        [sym_expression_statement] = ACTIONS(SHIFT(906)),
-        [sym_var_declaration] = ACTIONS(SHIFT(906)),
-        [sym_statement_block] = ACTIONS(SHIFT(906)),
-        [sym_if_statement] = ACTIONS(SHIFT(906)),
-        [sym_switch_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_statement] = ACTIONS(SHIFT(906)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(906)),
-        [sym_while_statement] = ACTIONS(SHIFT(906)),
-        [sym_try_statement] = ACTIONS(SHIFT(906)),
-        [sym_return_statement] = ACTIONS(SHIFT(906)),
-        [sym_throw_statement] = ACTIONS(SHIFT(906)),
-        [sym_break_statement] = ACTIONS(SHIFT(906)),
-        [sym_delete_statement] = ACTIONS(SHIFT(906)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(907)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(908)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1000)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1001)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1002)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(909)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(910)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(911)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(912)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(913)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(914)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(915)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(916)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(917)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(918)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(919)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1000] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_case] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_default] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym__expression] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_object] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_array] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1004)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_regex] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_number] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_null] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_true] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [sym_false] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
     },
     [1001] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1004)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1009)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1010)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1002] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym__statement] = ACTIONS(SHIFT(1003)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(32)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1003] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(32)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(1005)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(1006)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1004] = {
-        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__statement] = ACTIONS(SHIFT(1005)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1005] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1008)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1006] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1007)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1008)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1004)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1007] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1009)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1008] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1009)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1009] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1011)),
-    },
-    [1010] = {
-        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-    },
-    [1011] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
-    },
-    [1012] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1014)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1015)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1014)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-    },
-    [1013] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1014)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1015)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1014)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
-    },
-    [1014] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_case] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_default] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-    },
-    [1015] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1016)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1016)),
-    },
-    [1016] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_case] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_default] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-    },
-    [1017] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_case] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_default] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-    },
-    [1018] = {
-        [sym__statement] = ACTIONS(SHIFT(1019)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
+        [sym__statement] = ACTIONS(SHIFT(1010)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -36786,36 +36146,671 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [1010] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1011] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(999)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1012] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(999)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1013] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1014)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1015)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1016)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1014] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1002)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1015] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1002)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1016] = {
+        [sym__statement] = ACTIONS(SHIFT(1017)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1017] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_case] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_default] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1018] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1019)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1019] = {
+        [sym_case] = ACTIONS(SHIFT(831)),
+        [sym_default] = ACTIONS(SHIFT(831)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1020)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1021)),
+        [aux_sym_case] = ACTIONS(SHIFT(834)),
+        [aux_sym_default] = ACTIONS(SHIFT(835)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1020] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1022)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1021] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_case] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_default] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym__expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_object] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_array] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_number] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_null] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1022] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_case] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_default] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym__expression] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_object] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_array] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_number] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_null] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1023] = {
+        [sym__statement] = ACTIONS(SHIFT(1024)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1024] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_else] = ACTIONS(SHIFT(1025)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1025] = {
+        [sym__statement] = ACTIONS(SHIFT(1026)),
+        [sym_expression_statement] = ACTIONS(SHIFT(932)),
+        [sym_var_declaration] = ACTIONS(SHIFT(932)),
+        [sym_statement_block] = ACTIONS(SHIFT(932)),
+        [sym_if_statement] = ACTIONS(SHIFT(932)),
+        [sym_switch_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_statement] = ACTIONS(SHIFT(932)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(932)),
+        [sym_while_statement] = ACTIONS(SHIFT(932)),
+        [sym_try_statement] = ACTIONS(SHIFT(932)),
+        [sym_return_statement] = ACTIONS(SHIFT(932)),
+        [sym_throw_statement] = ACTIONS(SHIFT(932)),
+        [sym_break_statement] = ACTIONS(SHIFT(932)),
+        [sym_delete_statement] = ACTIONS(SHIFT(932)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(933)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(934)),
+        [aux_sym_var] = ACTIONS(SHIFT(935)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(936)),
+        [aux_sym_if] = ACTIONS(SHIFT(937)),
+        [aux_sym_switch] = ACTIONS(SHIFT(938)),
+        [aux_sym_for] = ACTIONS(SHIFT(939)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(940)),
+        [aux_sym_try] = ACTIONS(SHIFT(941)),
+        [aux_sym_return] = ACTIONS(SHIFT(942)),
+        [aux_sym_throw] = ACTIONS(SHIFT(943)),
+        [aux_sym_break] = ACTIONS(SHIFT(944)),
+        [aux_sym_delete] = ACTIONS(SHIFT(945)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1026] = {
         [sym__statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -36848,7 +36843,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -36859,38 +36877,16 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
     },
-    [1020] = {
+    [1027] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1031)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1032)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1009)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1022)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
-    [1021] = {
+    [1028] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -36924,7 +36920,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -36935,47 +36971,68 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [1022] = {
+    [1029] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(35)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym__expression, 1)),
+    },
+    [1030] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(35)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(28)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(29)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+    },
+    [1031] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1033)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1032] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -37009,7 +37066,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -37020,62 +37117,52 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
     },
-    [1023] = {
+    [1033] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1025)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1026)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1025)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_object, 4)),
     },
-    [1024] = {
+    [1034] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1036)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1037)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1025)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1026)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1025)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym__line_break] = ACTIONS(SHIFT(1037)),
     },
-    [1025] = {
+    [1035] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1036)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1037)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1037)),
+    },
+    [1036] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1038)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1038)),
+    },
+    [1037] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -37108,7 +37195,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -37119,39 +37233,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
     },
-    [1026] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1027)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1027)),
-    },
-    [1027] = {
+    [1038] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -37184,7 +37267,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -37195,31 +37302,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
     },
-    [1028] = {
+    [1039] = {
         [sym__statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -37253,7 +37337,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -37264,99 +37388,609 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1040] = {
+        [sym__statement] = ACTIONS(SHIFT(1041)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1041] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_case] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_default] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym__expression] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_object] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_array] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_regex] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_number] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_null] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_true] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym_false] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1042] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1031)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1044)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [1043] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+    },
+    [1044] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+    },
+    [1045] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1047)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1048)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1048)),
+    },
+    [1046] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1047)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1048)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1048)),
+    },
+    [1047] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1049)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1049)),
+    },
+    [1048] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_case] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_default] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1049] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_case] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_default] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym__expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_object] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_array] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_number] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_null] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1050] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_case] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_default] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [1029] = {
+    [1051] = {
         [sym_case] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [sym_default] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
         [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-    },
-    [1030] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
+        [aux_sym_case] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
+        [aux_sym_default] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(1031)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
-    [1031] = {
-        [sym__statement] = ACTIONS(SHIFT(811)),
-        [sym_expression_statement] = ACTIONS(SHIFT(812)),
-        [sym_var_declaration] = ACTIONS(SHIFT(812)),
-        [sym_statement_block] = ACTIONS(SHIFT(812)),
-        [sym_if_statement] = ACTIONS(SHIFT(812)),
-        [sym_switch_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_statement] = ACTIONS(SHIFT(812)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(812)),
-        [sym_while_statement] = ACTIONS(SHIFT(812)),
-        [sym_try_statement] = ACTIONS(SHIFT(812)),
-        [sym_return_statement] = ACTIONS(SHIFT(812)),
-        [sym_throw_statement] = ACTIONS(SHIFT(812)),
-        [sym_break_statement] = ACTIONS(SHIFT(812)),
-        [sym_delete_statement] = ACTIONS(SHIFT(812)),
+    [1052] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(1053)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1053] = {
+        [sym__statement] = ACTIONS(SHIFT(837)),
+        [sym_expression_statement] = ACTIONS(SHIFT(838)),
+        [sym_var_declaration] = ACTIONS(SHIFT(838)),
+        [sym_statement_block] = ACTIONS(SHIFT(838)),
+        [sym_if_statement] = ACTIONS(SHIFT(838)),
+        [sym_switch_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_statement] = ACTIONS(SHIFT(838)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(838)),
+        [sym_while_statement] = ACTIONS(SHIFT(838)),
+        [sym_try_statement] = ACTIONS(SHIFT(838)),
+        [sym_return_statement] = ACTIONS(SHIFT(838)),
+        [sym_throw_statement] = ACTIONS(SHIFT(838)),
+        [sym_break_statement] = ACTIONS(SHIFT(838)),
+        [sym_delete_statement] = ACTIONS(SHIFT(838)),
         [sym_case] = ACTIONS(REDUCE(sym_case, 3)),
         [sym_default] = ACTIONS(REDUCE(sym_case, 3)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(813)),
+        [sym__expression] = ACTIONS(SHIFT(839)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -37371,51 +38005,51 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(814)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1054)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_case, 3)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(841)),
+        [aux_sym_var] = ACTIONS(SHIFT(842)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(843)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_case, 3)),
+        [aux_sym_if] = ACTIONS(SHIFT(844)),
+        [aux_sym_switch] = ACTIONS(SHIFT(845)),
+        [aux_sym_for] = ACTIONS(SHIFT(846)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(847)),
+        [aux_sym_try] = ACTIONS(SHIFT(848)),
+        [aux_sym_return] = ACTIONS(SHIFT(849)),
+        [aux_sym_throw] = ACTIONS(SHIFT(850)),
+        [aux_sym_break] = ACTIONS(SHIFT(851)),
+        [aux_sym_delete] = ACTIONS(SHIFT(852)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_case, 3)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_case, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1032)),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_case, 3)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(816)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(817)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_case, 3)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(818)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(819)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(820)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(821)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(822)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(823)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(824)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(825)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(826)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_case, 3)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_case, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1032] = {
+    [1054] = {
         [sym_case] = ACTIONS(REDUCE(sym_case, 4)),
         [sym_default] = ACTIONS(REDUCE(sym_case, 4)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_case, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_case, 4)),
+        [aux_sym_case] = ACTIONS(REDUCE(sym_case, 4)),
+        [aux_sym_default] = ACTIONS(REDUCE(sym_case, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(REDUCE(sym_case, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_case, 4)),
-        [aux_sym_STR_case] = ACTIONS(REDUCE(sym_case, 4)),
-        [aux_sym_STR_default] = ACTIONS(REDUCE(sym_case, 4)),
     },
-    [1033] = {
+    [1055] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -37446,7 +38080,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -37457,993 +38110,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-    },
-    [1034] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_switch_statement_repeat1, 2)),
-    },
-    [1035] = {
-        [sym__statement] = ACTIONS(SHIFT(1036)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [1036] = {
-        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(SHIFT(1141)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-    },
-    [1037] = {
-        [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym__expression] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_object] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_array] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_function_call] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_member_access] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_ternary] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_number] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_identifier] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_null] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_undefined] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
-    },
-    [1038] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1140)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1140)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
-    },
-    [1039] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1140)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1140)),
-    },
-    [1040] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(1135)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1135)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1136)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [1041] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_pair] = ACTIONS(SHIFT(29)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1132)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(1002)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(1003)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1072)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1133)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [1042] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(1128)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
-    },
-    [1043] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(1123)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(800)),
-    },
-    [1044] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1087)),
-    },
-    [1045] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(1085)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
-    },
-    [1046] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1059)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1060)),
-    },
-    [1047] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1056)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT(1057)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1057)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [1048] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1054)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [1049] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1053)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1053)),
-    },
-    [1050] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(199)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
-        [sym_member_access] = ACTIONS(SHIFT(1051)),
-        [sym_subscript_access] = ACTIONS(SHIFT(1051)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
-    },
-    [1051] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1052)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1052)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
-    },
-    [1052] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-    },
-    [1053] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
-    },
-    [1054] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1055)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1055)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
-    },
-    [1055] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
     },
     [1056] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_switch_statement_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1058)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1058)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1057] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
-    },
-    [1058] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
-    },
-    [1059] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_catch] = ACTIONS(SHIFT(1065)),
-        [sym_finally] = ACTIONS(SHIFT(1066)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_catch] = ACTIONS(SHIFT(1067)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(1068)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
-    },
-    [1060] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(1058)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -38459,48 +38148,993 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1062)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1063)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [1058] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_else] = ACTIONS(SHIFT(1163)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1059] = {
+        [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym__expression] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_object] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_array] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_function_call] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_member_access] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_ternary] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_number] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_identifier] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_null] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_undefined] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1060] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1162)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1162)),
     },
     [1061] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1162)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1064)),
+        [sym__line_break] = ACTIONS(SHIFT(1162)),
     },
     [1062] = {
+        [sym_var_assignment] = ACTIONS(SHIFT(1157)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1157)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1158)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1064)),
     },
     [1063] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [sym_pair] = ACTIONS(SHIFT(32)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1093)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1154)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1155)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(1029)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(1030)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1064] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(1150)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1065] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(1145)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(826)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1066] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1109)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1067] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(1107)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1068] = {
+        [sym_statement_block] = ACTIONS(SHIFT(1081)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1082)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1069] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(1078)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1079)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT(1079)),
+    },
+    [1070] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(1076)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1071] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1075)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1075)),
+    },
+    [1072] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(227)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
+        [sym_member_access] = ACTIONS(SHIFT(1073)),
+        [sym_subscript_access] = ACTIONS(SHIFT(1073)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1073] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1074)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1074)),
+    },
+    [1074] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1075] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1076] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1077)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1077)),
+    },
+    [1077] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1078] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1080)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1080)),
+    },
+    [1079] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1080] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym__expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_object] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_array] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_number] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_null] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1081] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_catch] = ACTIONS(SHIFT(1087)),
+        [sym_finally] = ACTIONS(SHIFT(1088)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_object] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_array] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_catch] = ACTIONS(SHIFT(1089)),
+        [aux_sym_finally] = ACTIONS(SHIFT(1090)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_number] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_null] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1082] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1083)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1084)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1085)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1083] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1086)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1084] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1086)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [1085] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -38533,7 +39167,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -38544,97 +39200,75 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [1064] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [1086] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
-    [1065] = {
+    [1087] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -38649,7 +39283,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_throw_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_break_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_delete_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [sym_finally] = ACTIONS(SHIFT(1084)),
+        [sym_finally] = ACTIONS(SHIFT(1106)),
         [sym__paren_expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__expression] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_object] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -38666,7 +39300,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_finally] = ACTIONS(SHIFT(1090)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -38677,29 +39332,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(1068)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
-    [1066] = {
+    [1088] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -38730,7 +39364,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -38741,39 +39395,19 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
-    [1067] = {
+    [1089] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1097)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1075)),
     },
-    [1068] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1069)),
+    [1090] = {
+        [sym_statement_block] = ACTIONS(SHIFT(1091)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1092)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1070)),
     },
-    [1069] = {
+    [1091] = {
         [sym__statement] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -38804,7 +39438,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -38815,44 +39469,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
     },
-    [1070] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [1092] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -38867,49 +39501,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1071)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1093)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1094)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1095)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1072)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1073)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1071] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1074)),
-    },
-    [1072] = {
+    [1093] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1096)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1074)),
     },
-    [1073] = {
+    [1094] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1096)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [1095] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -38940,7 +39574,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -38951,108 +39605,88 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [1074] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [1096] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [1075] = {
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1076)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1076)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [1076] = {
+    [1097] = {
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1098)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1098)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1098] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1099)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1077)),
     },
-    [1077] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1078)),
+    [1099] = {
+        [sym_statement_block] = ACTIONS(SHIFT(1100)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1101)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1079)),
     },
-    [1078] = {
+    [1100] = {
         [sym__statement] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -39084,7 +39718,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -39095,45 +39750,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
     },
-    [1079] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [1101] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -39148,49 +39782,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1080)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1102)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1103)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1104)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1081)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1082)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1080] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1083)),
-    },
-    [1081] = {
+    [1102] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1105)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1083)),
     },
-    [1082] = {
+    [1103] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1105)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [1104] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -39222,7 +39856,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -39233,94 +39888,73 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [1083] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
+    [1105] = {
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
-    [1084] = {
+    [1106] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -39351,7 +39985,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -39362,44 +40016,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
     },
-    [1085] = {
-        [sym__statement] = ACTIONS(SHIFT(1086)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1107] = {
+        [sym__statement] = ACTIONS(SHIFT(1108)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -39414,36 +40048,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1086] = {
+    [1108] = {
         [sym__statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -39474,7 +40108,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -39485,247 +40139,219 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
     },
-    [1087] = {
-        [sym_var_declaration] = ACTIONS(SHIFT(1088)),
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(1089)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+    [1109] = {
+        [sym_var_declaration] = ACTIONS(SHIFT(1110)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(1111)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1110)),
+        [aux_sym_var] = ACTIONS(SHIFT(1112)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(1090)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(1113)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1088)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1091)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
-    [1088] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(1116)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1117)),
+    [1110] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(1138)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1139)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1140)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1118)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
-    [1089] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+    [1111] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1123)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1101)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
-    [1090] = {
+    [1112] = {
+        [sym_var_assignment] = ACTIONS(SHIFT(709)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(709)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1118)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1113] = {
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(1114)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1097)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
-    [1091] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(600)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(600)),
+    [1114] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(1115)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1092)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
-    [1092] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(602)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(603)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(602)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1093)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
-    },
-    [1093] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1094)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [1094] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [1115] = {
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1116)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1095)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [1095] = {
-        [sym__statement] = ACTIONS(SHIFT(1096)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1116] = {
+        [sym__statement] = ACTIONS(SHIFT(1117)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -39740,219 +40366,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1096] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-    },
-    [1097] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
-        [sym__expression] = ACTIONS(SHIFT(1098)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
-    },
-    [1098] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1099)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [1099] = {
-        [sym__statement] = ACTIONS(SHIFT(1100)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [1100] = {
+    [1117] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
@@ -39983,7 +40426,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
@@ -39994,176 +40457,92 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
     },
-    [1101] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
-        [sym__expression] = ACTIONS(SHIFT(1102)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1103)),
+    [1118] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(711)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(712)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_in] = ACTIONS(SHIFT(1119)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1104)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
+        [sym__line_break] = ACTIONS(SHIFT(712)),
     },
-    [1102] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+    [1119] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1120)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1120] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1121)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
-    [1103] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1111)),
-    },
-    [1104] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1105)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1106)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1107)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
-    },
-    [1105] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1109)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [1106] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1109)),
-    },
-    [1107] = {
-        [sym__statement] = ACTIONS(SHIFT(1108)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1121] = {
+        [sym__statement] = ACTIONS(SHIFT(1122)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -40178,36 +40557,291 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1108] = {
+    [1122] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1123] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
+        [sym__expression] = ACTIONS(SHIFT(1124)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1125)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1126)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1124] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1133)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1125] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1133)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1126] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1127)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1128)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1129)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1127] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1131)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1128] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1131)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1129] = {
+        [sym__statement] = ACTIONS(SHIFT(1130)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1130] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -40238,7 +40872,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -40249,44 +40903,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
     },
-    [1109] = {
-        [sym__statement] = ACTIONS(SHIFT(1110)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1131] = {
+        [sym__statement] = ACTIONS(SHIFT(1132)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -40301,36 +40935,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1110] = {
+    [1132] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -40361,7 +40995,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -40372,110 +41026,90 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
     },
-    [1111] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1112)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1113)),
+    [1133] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1134)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1135)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1131)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1109)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
-    [1112] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [1134] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1136)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1114)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [1113] = {
+    [1135] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1136)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1114)),
     },
-    [1114] = {
-        [sym__statement] = ACTIONS(SHIFT(1115)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1136] = {
+        [sym__statement] = ACTIONS(SHIFT(1137)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -40490,36 +41124,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1115] = {
+    [1137] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -40550,7 +41184,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -40561,139 +41215,119 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
     },
-    [1116] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+    [1138] = {
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1126)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1104)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
-    [1117] = {
+    [1139] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1126)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1104)),
     },
-    [1118] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1119)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1120)),
+    [1140] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
+        [sym__expression] = ACTIONS(SHIFT(1141)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1142)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1143)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1121)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
-    [1119] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+    [1141] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1129)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1107)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
-    [1120] = {
+    [1142] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1129)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1107)),
     },
-    [1121] = {
-        [sym__statement] = ACTIONS(SHIFT(1122)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1143] = {
+        [sym__statement] = ACTIONS(SHIFT(1144)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -40708,36 +41342,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1122] = {
+    [1144] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -40768,7 +41402,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -40779,48 +41433,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
     },
-    [1123] = {
+    [1145] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1146)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1124)),
     },
-    [1124] = {
-        [sym_case] = ACTIONS(SHIFT(805)),
-        [sym_default] = ACTIONS(SHIFT(805)),
+    [1146] = {
+        [sym_case] = ACTIONS(SHIFT(831)),
+        [sym_default] = ACTIONS(SHIFT(831)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1147)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1148)),
+        [aux_sym_case] = ACTIONS(SHIFT(834)),
+        [aux_sym_default] = ACTIONS(SHIFT(835)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1125)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1126)),
-        [aux_sym_STR_case] = ACTIONS(SHIFT(808)),
-        [aux_sym_STR_default] = ACTIONS(SHIFT(809)),
     },
-    [1125] = {
+    [1147] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1149)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1127)),
     },
-    [1126] = {
+    [1148] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -40851,7 +41485,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -40862,28 +41516,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
     },
-    [1127] = {
+    [1149] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -40914,7 +41548,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -40925,44 +41579,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
     },
-    [1128] = {
-        [sym__statement] = ACTIONS(SHIFT(1129)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1150] = {
+        [sym__statement] = ACTIONS(SHIFT(1151)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -40977,36 +41611,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1129] = {
+    [1151] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -41037,7 +41671,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_else] = ACTIONS(SHIFT(1152)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -41048,44 +41702,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(SHIFT(1130)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
     },
-    [1130] = {
-        [sym__statement] = ACTIONS(SHIFT(1131)),
-        [sym_expression_statement] = ACTIONS(SHIFT(1037)),
-        [sym_var_declaration] = ACTIONS(SHIFT(1037)),
-        [sym_statement_block] = ACTIONS(SHIFT(1037)),
-        [sym_if_statement] = ACTIONS(SHIFT(1037)),
-        [sym_switch_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_statement] = ACTIONS(SHIFT(1037)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(1037)),
-        [sym_while_statement] = ACTIONS(SHIFT(1037)),
-        [sym_try_statement] = ACTIONS(SHIFT(1037)),
-        [sym_return_statement] = ACTIONS(SHIFT(1037)),
-        [sym_throw_statement] = ACTIONS(SHIFT(1037)),
-        [sym_break_statement] = ACTIONS(SHIFT(1037)),
-        [sym_delete_statement] = ACTIONS(SHIFT(1037)),
+    [1152] = {
+        [sym__statement] = ACTIONS(SHIFT(1153)),
+        [sym_expression_statement] = ACTIONS(SHIFT(1059)),
+        [sym_var_declaration] = ACTIONS(SHIFT(1059)),
+        [sym_statement_block] = ACTIONS(SHIFT(1059)),
+        [sym_if_statement] = ACTIONS(SHIFT(1059)),
+        [sym_switch_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_statement] = ACTIONS(SHIFT(1059)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(1059)),
+        [sym_while_statement] = ACTIONS(SHIFT(1059)),
+        [sym_try_statement] = ACTIONS(SHIFT(1059)),
+        [sym_return_statement] = ACTIONS(SHIFT(1059)),
+        [sym_throw_statement] = ACTIONS(SHIFT(1059)),
+        [sym_break_statement] = ACTIONS(SHIFT(1059)),
+        [sym_delete_statement] = ACTIONS(SHIFT(1059)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(1038)),
+        [sym__expression] = ACTIONS(SHIFT(1060)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -41100,36 +41734,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1039)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1061)),
+        [aux_sym_var] = ACTIONS(SHIFT(1062)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1063)),
+        [aux_sym_if] = ACTIONS(SHIFT(1064)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1065)),
+        [aux_sym_for] = ACTIONS(SHIFT(1066)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1067)),
+        [aux_sym_try] = ACTIONS(SHIFT(1068)),
+        [aux_sym_return] = ACTIONS(SHIFT(1069)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1070)),
+        [aux_sym_break] = ACTIONS(SHIFT(1071)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1072)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1040)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1041)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1042)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1043)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1044)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1045)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1046)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1047)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1048)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1049)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1050)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1131] = {
+    [1153] = {
         [sym__statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -41160,7 +41794,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -41171,36 +41825,16 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
     },
-    [1132] = {
+    [1154] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1031)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1156)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1009)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1134)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
-    [1133] = {
+    [1155] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -41232,7 +41866,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -41243,45 +41914,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [1134] = {
+    [1156] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -41313,7 +41947,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -41324,60 +41995,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
     },
-    [1135] = {
+    [1157] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1159)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1160)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1137)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1138)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1137)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
+        [sym__line_break] = ACTIONS(SHIFT(1160)),
     },
-    [1136] = {
+    [1158] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1159)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1160)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1137)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1138)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1137)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym__line_break] = ACTIONS(SHIFT(1160)),
     },
-    [1137] = {
+    [1159] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1161)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1161)),
+    },
+    [1160] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -41408,7 +42047,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -41419,37 +42082,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
     },
-    [1138] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1139)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1139)),
-    },
-    [1139] = {
+    [1161] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -41480,7 +42114,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -41491,29 +42146,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
     },
-    [1140] = {
+    [1162] = {
         [sym__statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -41545,7 +42179,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -41556,61 +42227,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
     },
-    [1141] = {
-        [sym__statement] = ACTIONS(SHIFT(1142)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+    [1163] = {
+        [sym__statement] = ACTIONS(SHIFT(1164)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -41625,36 +42259,36 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(515)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(541)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
-    [1142] = {
+    [1164] = {
         [sym__statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -41685,7 +42319,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -41696,35 +42349,16 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
     },
-    [1143] = {
+    [1165] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1031)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1167)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1009)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1145)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
-    [1144] = {
+    [1166] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -41756,7 +42390,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -41767,44 +42437,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
-    [1145] = {
+    [1167] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -41836,7 +42470,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -41847,59 +42517,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
     },
-    [1146] = {
+    [1168] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1170)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1171)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1148)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1149)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1148)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
+        [sym__line_break] = ACTIONS(SHIFT(1171)),
     },
-    [1147] = {
+    [1169] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1170)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1171)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1148)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1149)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1148)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym__line_break] = ACTIONS(SHIFT(1171)),
     },
-    [1148] = {
+    [1170] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1172)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1172)),
+    },
+    [1171] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -41930,7 +42569,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -41941,36 +42603,8 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
     },
-    [1149] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1150)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1150)),
-    },
-    [1150] = {
+    [1172] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -42001,7 +42635,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -42012,2430 +42666,1406 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-    },
-    [1151] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
-    },
-    [1152] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
-    },
-    [1153] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_formal_parameters, 2)),
-    },
-    [1154] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1155)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-    },
-    [1155] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_formal_parameters_repeat1] = ACTIONS(SHIFT(1156)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(1154)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_formal_parameters_repeat1, 2)),
-    },
-    [1156] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(aux_sym_formal_parameters_repeat1, 3)),
-    },
-    [1157] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1158)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(180)),
-    },
-    [1158] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
-    },
-    [1159] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1160)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1157)),
-    },
-    [1160] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1161)),
-    },
-    [1161] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1162)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(180)),
-    },
-    [1162] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
-    },
-    [1163] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1166)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1167)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
-    },
-    [1164] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1166)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1167)),
-    },
-    [1165] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
-    },
-    [1166] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1168)),
-    },
-    [1167] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
-    },
-    [1168] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
-    },
-    [1169] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1171)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [1170] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1171)),
-    },
-    [1171] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-    },
-    [1172] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1174)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1175)),
     },
     [1173] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
     },
     [1174] = {
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1176)),
     },
     [1175] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_statement_block] = ACTIONS(SHIFT(1176)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(208)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [1176] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [1177] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(1180)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(201)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [1178] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(106)),
-        [sym__expression] = ACTIONS(SHIFT(1179)),
-        [sym_object] = ACTIONS(SHIFT(106)),
-        [sym_array] = ACTIONS(SHIFT(106)),
-        [sym_function_expression] = ACTIONS(SHIFT(106)),
-        [sym_function_call] = ACTIONS(SHIFT(106)),
-        [sym_constructor_call] = ACTIONS(SHIFT(106)),
-        [sym_member_access] = ACTIONS(SHIFT(108)),
-        [sym_subscript_access] = ACTIONS(SHIFT(108)),
-        [sym_assignment] = ACTIONS(SHIFT(106)),
-        [sym_math_assignment] = ACTIONS(SHIFT(106)),
-        [sym_ternary] = ACTIONS(SHIFT(106)),
-        [sym_bool_op] = ACTIONS(SHIFT(106)),
-        [sym_math_op] = ACTIONS(SHIFT(106)),
-        [sym_rel_op] = ACTIONS(SHIFT(106)),
-        [sym_type_op] = ACTIONS(SHIFT(106)),
+        [sym_statement_block] = ACTIONS(SHIFT(1179)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(208)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(106)),
-        [sym_regex] = ACTIONS(SHIFT(106)),
-        [sym_number] = ACTIONS(SHIFT(106)),
-        [sym_identifier] = ACTIONS(SHIFT(110)),
-        [sym_null] = ACTIONS(SHIFT(106)),
-        [sym_undefined] = ACTIONS(SHIFT(106)),
-        [sym_true] = ACTIONS(SHIFT(106)),
-        [sym_false] = ACTIONS(SHIFT(106)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(111)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(112)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(114)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(115)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(116)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(117)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(118)),
     },
     [1179] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [1180] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1183)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1184)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [1181] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1183)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1184)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1183)),
     },
     [1182] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
     },
     [1183] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1185)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
     },
     [1184] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [1185] = {
-        [sym_arguments] = ACTIONS(SHIFT(1186)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
     },
     [1186] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1188)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
     },
     [1187] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1188)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1199)),
     },
     [1188] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1189)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1190)),
     },
     [1189] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1191)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1192)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1197)),
     },
     [1190] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1191)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1192)),
     },
     [1191] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1193)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [1192] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1193)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1194)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1195)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1193] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1196)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1194] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1196)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1196)),
     },
     [1195] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1196] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1197] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1198)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1192)),
     },
     [1198] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
     },
     [1199] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1200)),
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1197)),
     },
     [1200] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1201)),
     },
     [1201] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1202)),
+        [sym_arguments] = ACTIONS(SHIFT(1202)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1192)),
     },
     [1202] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
     },
     [1203] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_formal_parameters] = ACTIONS(SHIFT(1216)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1217)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1206)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1207)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [1204] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1205)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1206)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1207)),
     },
     [1205] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [sym_formal_parameters] = ACTIONS(SHIFT(1206)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1207)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [1206] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1214)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1208)),
     },
     [1207] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym_statement_block] = ACTIONS(SHIFT(1208)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1209)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [1208] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [1209] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1210)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1211)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1212)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1211)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1210] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1213)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1211)),
     },
     [1211] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1213)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1212] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1214)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1215)),
     },
     [1213] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
     },
     [1214] = {
+        [sym_statement_block] = ACTIONS(SHIFT(1215)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1209)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1216)),
     },
     [1215] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [1216] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1207)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [1217] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(1220)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_statement_block] = ACTIONS(SHIFT(1218)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1209)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [1218] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(1219)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [1219] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1222)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1223)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
     [1220] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1222)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1223)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
     [1221] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(1222)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
     },
     [1222] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1224)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
     },
     [1223] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
     },
     [1224] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1227)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1228)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
     },
     [1225] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1227)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1227)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1228)),
     },
     [1226] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1227)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
     },
     [1227] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1229)),
     },
     [1228] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1230)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1231)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
     },
     [1229] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
     },
     [1230] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1232)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [1231] = {
-        [sym_arguments] = ACTIONS(SHIFT(1232)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
     },
     [1232] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
     },
     [1233] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1245)),
     },
     [1234] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1235)),
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1237)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1238)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1236)),
     },
     [1235] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1237)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1238)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1243)),
     },
     [1236] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1237)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1238)),
     },
     [1237] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1239)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [1238] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
-        [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
-        [sym_object] = ACTIONS(SHIFT(4)),
-        [sym_array] = ACTIONS(SHIFT(4)),
-        [sym_function_expression] = ACTIONS(SHIFT(4)),
-        [sym_function_call] = ACTIONS(SHIFT(4)),
-        [sym_constructor_call] = ACTIONS(SHIFT(4)),
-        [sym_member_access] = ACTIONS(SHIFT(6)),
-        [sym_subscript_access] = ACTIONS(SHIFT(6)),
-        [sym_assignment] = ACTIONS(SHIFT(4)),
-        [sym_math_assignment] = ACTIONS(SHIFT(4)),
-        [sym_ternary] = ACTIONS(SHIFT(4)),
-        [sym_bool_op] = ACTIONS(SHIFT(4)),
-        [sym_math_op] = ACTIONS(SHIFT(4)),
-        [sym_rel_op] = ACTIONS(SHIFT(4)),
-        [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1239)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(4)),
-        [sym_regex] = ACTIONS(SHIFT(4)),
-        [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
-        [sym_null] = ACTIONS(SHIFT(4)),
-        [sym_undefined] = ACTIONS(SHIFT(4)),
-        [sym_true] = ACTIONS(SHIFT(4)),
-        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1240)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1241)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1239] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1242)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1240] = {
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(SHIFT(78)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(86)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(87)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(88)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(92)),
+        [aux_sym_LT] = ACTIONS(SHIFT(92)),
+        [aux_sym_GT] = ACTIONS(SHIFT(92)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(78)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1242)),
     },
     [1241] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(90)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(90)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(91)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(91)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1242] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1243] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1244)),
+        [sym_arguments] = ACTIONS(SHIFT(82)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(89)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(89)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1238)),
     },
     [1244] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_arguments] = ACTIONS(SHIFT(1245)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(83)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(84)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(85)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
     },
     [1245] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1246)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1243)),
     },
     [1246] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(1259)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1260)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1247)),
     },
     [1247] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1248)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1248)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1238)),
     },
     [1248] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym_formal_parameters] = ACTIONS(SHIFT(1249)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1250)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
     },
     [1249] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1257)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1252)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1253)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [1250] = {
+        [sym_statement_block] = ACTIONS(SHIFT(1251)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1252)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1252)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1253)),
     },
     [1251] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [1252] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1254)),
-    },
-    [1253] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
-    },
-    [1254] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
-    },
-    [1255] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1257)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [1256] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1257)),
-    },
-    [1257] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-    },
-    [1258] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1260)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1261)),
-    },
-    [1259] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-    },
-    [1260] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1262)),
-    },
-    [1261] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
-    },
-    [1262] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
-    },
-    [1263] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(1266)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
-    },
-    [1264] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(51)),
-        [sym__expression] = ACTIONS(SHIFT(1265)),
-        [sym_object] = ACTIONS(SHIFT(51)),
-        [sym_array] = ACTIONS(SHIFT(51)),
-        [sym_function_expression] = ACTIONS(SHIFT(51)),
-        [sym_function_call] = ACTIONS(SHIFT(51)),
-        [sym_constructor_call] = ACTIONS(SHIFT(51)),
-        [sym_member_access] = ACTIONS(SHIFT(53)),
-        [sym_subscript_access] = ACTIONS(SHIFT(53)),
-        [sym_assignment] = ACTIONS(SHIFT(51)),
-        [sym_math_assignment] = ACTIONS(SHIFT(51)),
-        [sym_ternary] = ACTIONS(SHIFT(51)),
-        [sym_bool_op] = ACTIONS(SHIFT(51)),
-        [sym_math_op] = ACTIONS(SHIFT(51)),
-        [sym_rel_op] = ACTIONS(SHIFT(51)),
-        [sym_type_op] = ACTIONS(SHIFT(51)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(51)),
-        [sym_regex] = ACTIONS(SHIFT(51)),
-        [sym_number] = ACTIONS(SHIFT(51)),
-        [sym_identifier] = ACTIONS(SHIFT(55)),
-        [sym_null] = ACTIONS(SHIFT(51)),
-        [sym_undefined] = ACTIONS(SHIFT(51)),
-        [sym_true] = ACTIONS(SHIFT(51)),
-        [sym_false] = ACTIONS(SHIFT(51)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(56)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(57)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(58)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(60)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(61)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(62)),
-    },
-    [1265] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
-    },
-    [1266] = {
-        [sym_arguments] = ACTIONS(SHIFT(64)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(65)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(73)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(67)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(74)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(75)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(76)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(68)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(77)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(78)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(79)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(73)),
-    },
-    [1267] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
-    },
-    [1268] = {
-        [sym_arguments] = ACTIONS(SHIFT(120)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1271)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(121)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1272)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(138)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(122)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(123)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(139)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(140)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(141)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(124)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(142)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(143)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(144)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(138)),
-    },
-    [1269] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1271)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(133)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1272)),
-    },
-    [1270] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
-    },
-    [1271] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1273)),
-    },
-    [1272] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
-    },
-    [1273] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
-    },
-    [1274] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-    },
-    [1275] = {
-        [sym_arguments] = ACTIONS(SHIFT(1276)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-    },
-    [1276] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-    },
-    [1277] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1289)),
-    },
-    [1278] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1279)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1280)),
-    },
-    [1279] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1287)),
-    },
-    [1280] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1281)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1282)),
-    },
-    [1281] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
-    },
-    [1282] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -44450,1205 +44080,1582 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1283)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1253)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1254)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1255)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1284)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1285)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [1253] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1256)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1254] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1256)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
+    },
+    [1255] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1256] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1257] = {
+        [sym_statement_block] = ACTIONS(SHIFT(1258)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1252)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1258] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1259] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1250)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1260] = {
+        [sym_statement_block] = ACTIONS(SHIFT(1261)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1252)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1261] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1262] = {
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1265)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1266)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1263] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1265)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1266)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1264] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1265] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1267)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1266] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1267] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1268] = {
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1270)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1269] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1270)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1270] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1271] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1273)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1274)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1272] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_COLON] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1273] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1275)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1274] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1275] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_COLON] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1276] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(36)),
+        [sym__expression] = ACTIONS(SHIFT(1277)),
+        [sym_object] = ACTIONS(SHIFT(36)),
+        [sym_array] = ACTIONS(SHIFT(36)),
+        [sym_function_expression] = ACTIONS(SHIFT(36)),
+        [sym_function_call] = ACTIONS(SHIFT(36)),
+        [sym_constructor_call] = ACTIONS(SHIFT(36)),
+        [sym_member_access] = ACTIONS(SHIFT(38)),
+        [sym_subscript_access] = ACTIONS(SHIFT(38)),
+        [sym_assignment] = ACTIONS(SHIFT(36)),
+        [sym_math_assignment] = ACTIONS(SHIFT(36)),
+        [sym_ternary] = ACTIONS(SHIFT(36)),
+        [sym_bool_op] = ACTIONS(SHIFT(36)),
+        [sym_math_op] = ACTIONS(SHIFT(36)),
+        [sym_rel_op] = ACTIONS(SHIFT(36)),
+        [sym_type_op] = ACTIONS(SHIFT(36)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(39)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(40)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(41)),
+        [aux_sym_function] = ACTIONS(SHIFT(42)),
+        [aux_sym_new] = ACTIONS(SHIFT(43)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(44)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(45)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(36)),
+        [sym_regex] = ACTIONS(SHIFT(36)),
+        [sym_number] = ACTIONS(SHIFT(36)),
+        [sym_identifier] = ACTIONS(SHIFT(46)),
+        [sym_null] = ACTIONS(SHIFT(36)),
+        [sym_undefined] = ACTIONS(SHIFT(36)),
+        [sym_true] = ACTIONS(SHIFT(36)),
+        [sym_false] = ACTIONS(SHIFT(36)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1277] = {
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(SHIFT(47)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(55)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(56)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(57)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_LT] = ACTIONS(SHIFT(61)),
+        [aux_sym_GT] = ACTIONS(SHIFT(61)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(47)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1278] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_member_access, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1279] = {
+        [sym_arguments] = ACTIONS(SHIFT(118)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(119)),
+        [aux_sym_in] = ACTIONS(SHIFT(114)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(120)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1281)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(121)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(122)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(123)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(124)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(125)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(125)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(126)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(126)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(127)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(127)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(128)),
+        [aux_sym_LT] = ACTIONS(SHIFT(128)),
+        [aux_sym_GT] = ACTIONS(SHIFT(128)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(114)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1280] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1281)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1281] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_subscript_access, 4)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
+    },
+    [1282] = {
+        [sym_arguments] = ACTIONS(SHIFT(158)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1285)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(159)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1286)),
+        [aux_sym_in] = ACTIONS(SHIFT(154)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(160)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(161)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(162)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(163)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(164)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(165)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(165)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(166)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(166)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(167)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(167)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(168)),
+        [aux_sym_LT] = ACTIONS(SHIFT(168)),
+        [aux_sym_GT] = ACTIONS(SHIFT(168)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(154)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1283] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1285)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(185)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1286)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1286)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1284] = {
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1286)),
     },
     [1285] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1287)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1286] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1287] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1288)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_arguments, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_arguments, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1282)),
     },
     [1288] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(SHIFT(47)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(55)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(56)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(57)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(61)),
+        [aux_sym_LT] = ACTIONS(SHIFT(61)),
+        [aux_sym_GT] = ACTIONS(SHIFT(61)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(47)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
     },
     [1289] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1290)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(59)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(59)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(60)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(60)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1287)),
     },
     [1290] = {
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1291)),
     },
     [1291] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1292)),
+        [sym_arguments] = ACTIONS(SHIFT(51)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(58)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(58)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1282)),
     },
     [1292] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym_arguments] = ACTIONS(SHIFT(1293)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(52)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(53)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(54)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
     },
     [1293] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1296)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1297)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [1294] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(1307)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1308)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1296)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1297)),
     },
     [1295] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1296)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [1296] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(1297)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1298)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1298)),
     },
     [1297] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1305)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [1298] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [sym_statement_block] = ACTIONS(SHIFT(1299)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1300)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [1299] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1301)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1300] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
+        [sym__paren_expression] = ACTIONS(SHIFT(4)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
+        [sym_object] = ACTIONS(SHIFT(4)),
+        [sym_array] = ACTIONS(SHIFT(4)),
+        [sym_function_expression] = ACTIONS(SHIFT(4)),
+        [sym_function_call] = ACTIONS(SHIFT(4)),
+        [sym_constructor_call] = ACTIONS(SHIFT(4)),
+        [sym_member_access] = ACTIONS(SHIFT(6)),
+        [sym_subscript_access] = ACTIONS(SHIFT(6)),
+        [sym_assignment] = ACTIONS(SHIFT(4)),
+        [sym_math_assignment] = ACTIONS(SHIFT(4)),
+        [sym_ternary] = ACTIONS(SHIFT(4)),
+        [sym_bool_op] = ACTIONS(SHIFT(4)),
+        [sym_math_op] = ACTIONS(SHIFT(4)),
+        [sym_rel_op] = ACTIONS(SHIFT(4)),
+        [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1301)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1302)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1303)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(SHIFT(4)),
+        [sym_regex] = ACTIONS(SHIFT(4)),
+        [sym_number] = ACTIONS(SHIFT(4)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
+        [sym_null] = ACTIONS(SHIFT(4)),
+        [sym_undefined] = ACTIONS(SHIFT(4)),
+        [sym_true] = ACTIONS(SHIFT(4)),
+        [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1301)),
     },
     [1301] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1304)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
     },
     [1302] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1304)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1304)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1305)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1303] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
     },
     [1304] = {
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1306)),
     },
     [1305] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [sym_statement_block] = ACTIONS(SHIFT(1306)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1300)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [1306] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [1307] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1326)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1298)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1308] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1325)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym_statement_block] = ACTIONS(SHIFT(1309)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1300)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1309] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1310)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1310] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1313)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1314)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1307)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(1311)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(1312)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(1313)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(1307)),
     },
     [1311] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(85)),
-        [sym__expression] = ACTIONS(SHIFT(1322)),
-        [sym_object] = ACTIONS(SHIFT(85)),
-        [sym_array] = ACTIONS(SHIFT(85)),
-        [sym_function_expression] = ACTIONS(SHIFT(85)),
-        [sym_function_call] = ACTIONS(SHIFT(85)),
-        [sym_constructor_call] = ACTIONS(SHIFT(85)),
-        [sym_member_access] = ACTIONS(SHIFT(87)),
-        [sym_subscript_access] = ACTIONS(SHIFT(87)),
-        [sym_assignment] = ACTIONS(SHIFT(85)),
-        [sym_math_assignment] = ACTIONS(SHIFT(85)),
-        [sym_ternary] = ACTIONS(SHIFT(85)),
-        [sym_bool_op] = ACTIONS(SHIFT(85)),
-        [sym_math_op] = ACTIONS(SHIFT(85)),
-        [sym_rel_op] = ACTIONS(SHIFT(85)),
-        [sym_type_op] = ACTIONS(SHIFT(85)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1313)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1314)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(85)),
-        [sym_regex] = ACTIONS(SHIFT(85)),
-        [sym_number] = ACTIONS(SHIFT(85)),
-        [sym_identifier] = ACTIONS(SHIFT(88)),
-        [sym_null] = ACTIONS(SHIFT(85)),
-        [sym_undefined] = ACTIONS(SHIFT(85)),
-        [sym_true] = ACTIONS(SHIFT(85)),
-        [sym_false] = ACTIONS(SHIFT(85)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(89)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(90)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(91)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(92)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(93)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(94)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(95)),
     },
     [1312] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1321)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1313] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1320)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1315)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1314] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1319)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1315] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1318)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1316] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1317)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1318)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1317] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1318)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_rel_op, 3)),
     },
     [1318] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [1319] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1321)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1322)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_math_op, 3)),
     },
     [1320] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1307)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(1307)),
     },
     [1321] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1323)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1307)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(1313)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(1307)),
     },
     [1322] = {
-        [sym_arguments] = ACTIONS(SHIFT(97)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(98)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(151)),
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(1323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(99)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(100)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(153)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(154)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(155)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(101)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(156)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(157)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(158)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(151)),
     },
     [1323] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(33)),
-        [sym__expression] = ACTIONS(SHIFT(1324)),
-        [sym_object] = ACTIONS(SHIFT(33)),
-        [sym_array] = ACTIONS(SHIFT(33)),
-        [sym_function_expression] = ACTIONS(SHIFT(33)),
-        [sym_function_call] = ACTIONS(SHIFT(33)),
-        [sym_constructor_call] = ACTIONS(SHIFT(33)),
-        [sym_member_access] = ACTIONS(SHIFT(35)),
-        [sym_subscript_access] = ACTIONS(SHIFT(35)),
-        [sym_assignment] = ACTIONS(SHIFT(33)),
-        [sym_math_assignment] = ACTIONS(SHIFT(33)),
-        [sym_ternary] = ACTIONS(SHIFT(33)),
-        [sym_bool_op] = ACTIONS(SHIFT(33)),
-        [sym_math_op] = ACTIONS(SHIFT(33)),
-        [sym_rel_op] = ACTIONS(SHIFT(33)),
-        [sym_type_op] = ACTIONS(SHIFT(33)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(33)),
-        [sym_regex] = ACTIONS(SHIFT(33)),
-        [sym_number] = ACTIONS(SHIFT(33)),
-        [sym_identifier] = ACTIONS(SHIFT(36)),
-        [sym_null] = ACTIONS(SHIFT(33)),
-        [sym_undefined] = ACTIONS(SHIFT(33)),
-        [sym_true] = ACTIONS(SHIFT(33)),
-        [sym_false] = ACTIONS(SHIFT(33)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(38)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(39)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(40)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(41)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(42)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(43)),
     },
     [1324] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_ternary, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1307)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(1311)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(1312)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(1313)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(1307)),
-    },
-    [1325] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1307)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(1311)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(1312)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(1313)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(1316)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(1307)),
-    },
-    [1326] = {
-        [sym_arguments] = ACTIONS(SHIFT(45)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(47)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(48)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(1314)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(1315)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-    },
-    [1327] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_object, 3)),
+    },
+    [1325] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_assignment, 3)),
+    },
+    [1326] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+    },
+    [1327] = {
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 2)),
     },
     [1328] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_bool_op, 2)),
     },
     [1329] = {
         [sym_arguments] = ACTIONS(SHIFT(1330)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 2)),
     },
     [1330] = {
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_constructor_call, 3)),
     },
     [1331] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(1344)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1345)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1343)),
     },
     [1332] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1333)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1333)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1334)),
     },
     [1333] = {
+        [sym_formal_parameters] = ACTIONS(SHIFT(1334)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1335)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(202)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1341)),
     },
     [1334] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1335)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1342)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1336)),
     },
     [1335] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [sym_statement_block] = ACTIONS(SHIFT(1336)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1337)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1336] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 5)),
+    },
+    [1337] = {
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -45663,306 +45670,299 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1337)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1338)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1339)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1340)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1338)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1339)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
-    },
-    [1337] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1340)),
     },
     [1338] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1341)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1340)),
     },
     [1339] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1341)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1340] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1341] = {
-        [sym_statement_block] = ACTIONS(SHIFT(1342)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1336)),
+        [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
     },
     [1342] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym_statement_block] = ACTIONS(SHIFT(1343)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1337)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 5)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 5)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1343] = {
-        [sym_formal_parameters] = ACTIONS(SHIFT(1344)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(177)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1341)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 6)),
     },
     [1344] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1335)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1345)),
     },
     [1345] = {
         [sym_statement_block] = ACTIONS(SHIFT(1346)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1337)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1336)),
     },
     [1346] = {
-        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym_arguments] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_function_expression, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_function_expression, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_function_expression, 6)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_function_expression, 6)),
+        [sym__line_break] = ACTIONS(REDUCE(sym_function_expression, 4)),
     },
     [1347] = {
-        [sym_arguments] = ACTIONS(SHIFT(280)),
+        [sym_arguments] = ACTIONS(SHIFT(311)),
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1350)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(312)),
+        [aux_sym_in] = ACTIONS(SHIFT(307)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(313)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1351)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(314)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(315)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(316)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(317)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(318)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(318)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(319)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(319)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(320)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(320)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(321)),
+        [aux_sym_LT] = ACTIONS(SHIFT(321)),
+        [aux_sym_GT] = ACTIONS(SHIFT(321)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(307)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1350)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(281)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(323)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(282)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1351)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(283)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(324)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(325)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(326)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(284)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(327)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(328)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(329)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(323)),
     },
     [1348] = {
+        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1350)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(366)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1351)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_array_repeat1] = ACTIONS(SHIFT(1350)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(318)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1351)),
     },
     [1349] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [1350] = {
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(1352)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(1352)),
     },
     [1351] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [1352] = {
         [sym_arguments] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [1353] = {
         [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1354)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1354)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1354)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [1354] = {
         [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -45996,8 +45996,48 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -46008,46 +46048,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
     },
     [1355] = {
         [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -46080,8 +46080,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -46092,49 +46111,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
     },
     [1356] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1357)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1357)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1357)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
     [1357] = {
         [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -46168,8 +46168,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -46180,65 +46215,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
     },
     [1358] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1360)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1360)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1360)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
     [1359] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -46271,8 +46271,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -46283,25 +46302,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
     },
     [1360] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -46335,8 +46335,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -46347,41 +46382,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
     },
     [1361] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -46416,8 +46416,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_catch] = ACTIONS(SHIFT(1369)),
+        [aux_sym_finally] = ACTIONS(SHIFT(1370)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -46428,44 +46448,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_catch] = ACTIONS(SHIFT(1369)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(1370)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
     },
     [1362] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -46480,47 +46480,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1363)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1363)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1364)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1365)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1364)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1365)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1363] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1366)),
-    },
-    [1364] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1366)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1366)),
+    },
+    [1364] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1366)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1365] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -46555,8 +46555,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -46567,92 +46587,72 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1366] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1367] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -46686,8 +46686,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_finally] = ACTIONS(SHIFT(1370)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -46698,25 +46717,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(1370)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
     [1368] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -46749,8 +46749,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -46761,35 +46779,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
     [1369] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1377)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1377)),
     },
     [1370] = {
         [sym_statement_block] = ACTIONS(SHIFT(1371)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1372)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1372)),
     },
     [1371] = {
         [sym__statement] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -46822,8 +46822,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_finally, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -46834,42 +46852,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
     },
     [1372] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -46884,47 +46884,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1373)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1373)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1374)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1375)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1374)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1375)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1373] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1376)),
-    },
-    [1374] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1376)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1376)),
+    },
+    [1374] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1376)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1375] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -46957,8 +46957,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -46969,86 +46987,68 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1376] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1377] = {
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1378)),
@@ -47057,15 +47057,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1378] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1379)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1379)),
     },
     [1379] = {
         [sym_statement_block] = ACTIONS(SHIFT(1380)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1381)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1381)),
     },
     [1380] = {
         [sym__statement] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -47099,8 +47099,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_catch, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -47111,43 +47130,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
     },
     [1381] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -47162,47 +47162,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1382)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1382)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1383)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1384)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1383)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1384)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1382] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1385)),
-    },
-    [1383] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1385)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1385)),
+    },
+    [1383] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1385)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1384] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -47236,8 +47236,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -47248,89 +47267,70 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1385] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1386] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -47363,8 +47363,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -47375,24 +47393,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
     },
     [1387] = {
         [sym__statement] = ACTIONS(SHIFT(1388)),
@@ -47425,34 +47425,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1388] = {
         [sym__statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -47485,8 +47485,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -47497,283 +47515,257 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
     },
     [1389] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1391)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1391)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1390] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1391)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1391)),
     },
     [1391] = {
         [sym_arguments] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__paren_expression, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__paren_expression, 3)),
     },
     [1392] = {
         [sym_var_declaration] = ACTIONS(SHIFT(1393)),
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
         [sym__expression] = ACTIONS(SHIFT(1394)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1393)),
+        [aux_sym_var] = ACTIONS(SHIFT(1395)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(1395)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(1396)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1393)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1396)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [1393] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
         [sym__expression] = ACTIONS(SHIFT(1421)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1422)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1423)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1423)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [1394] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1406)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1406)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [1395] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_var_assignment] = ACTIONS(SHIFT(709)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(709)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1401)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1402)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
     [1396] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(600)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(600)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(1397)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1397)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1397] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(1398)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(602)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(603)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(602)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1398)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1398] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1399)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1399)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1399] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1400)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [1400] = {
-        [sym__statement] = ACTIONS(SHIFT(1401)),
+        [sym__statement] = ACTIONS(SHIFT(1400)),
         [sym_expression_statement] = ACTIONS(SHIFT(3)),
         [sym_var_declaration] = ACTIONS(SHIFT(3)),
         [sym_statement_block] = ACTIONS(SHIFT(3)),
@@ -47803,156 +47795,164 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [1400] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1401] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(711)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(712)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_in] = ACTIONS(SHIFT(1402)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__line_break] = ACTIONS(SHIFT(712)),
     },
     [1402] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1403)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
     },
     [1403] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1404)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1404)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
     },
     [1404] = {
         [sym__statement] = ACTIONS(SHIFT(1405)),
@@ -47985,228 +47985,228 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1405] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
     },
     [1406] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
         [sym__expression] = ACTIONS(SHIFT(1407)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1408)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1409)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1409)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [1407] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1416)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1416)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [1408] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1416)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1416)),
     },
     [1409] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1410)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1411)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1412)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1412)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1410] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1414)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1414)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1411] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1414)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1414)),
     },
     [1412] = {
         [sym__statement] = ACTIONS(SHIFT(1413)),
@@ -48239,34 +48239,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1413] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -48299,8 +48299,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -48311,24 +48329,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
     },
     [1414] = {
         [sym__statement] = ACTIONS(SHIFT(1415)),
@@ -48361,34 +48361,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1415] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -48421,8 +48421,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -48433,90 +48451,72 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
     },
     [1416] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1417)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1418)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1414)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1414)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1417] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1419)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1419)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1418] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1419)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1419)),
     },
     [1419] = {
         [sym__statement] = ACTIONS(SHIFT(1420)),
@@ -48549,34 +48549,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1420] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -48609,8 +48609,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -48621,119 +48639,101 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
     },
     [1421] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1409)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1409)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [1422] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1409)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1409)),
     },
     [1423] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1424)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1425)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1426)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1426)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1424] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1412)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1412)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1425] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1412)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1412)),
     },
     [1426] = {
         [sym__statement] = ACTIONS(SHIFT(1427)),
@@ -48766,34 +48766,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1427] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -48826,8 +48826,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -48838,44 +48856,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
     },
     [1428] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1429)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1429)),
     },
     [1429] = {
-        [sym_case] = ACTIONS(SHIFT(805)),
-        [sym_default] = ACTIONS(SHIFT(805)),
+        [sym_case] = ACTIONS(SHIFT(831)),
+        [sym_default] = ACTIONS(SHIFT(831)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1430)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1431)),
+        [aux_sym_case] = ACTIONS(SHIFT(834)),
+        [aux_sym_default] = ACTIONS(SHIFT(835)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1430)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1431)),
-        [aux_sym_STR_case] = ACTIONS(SHIFT(808)),
-        [aux_sym_STR_default] = ACTIONS(SHIFT(809)),
     },
     [1430] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1432)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1432)),
     },
     [1431] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -48908,8 +48908,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -48920,24 +48938,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
     },
     [1432] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -48970,8 +48970,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -48982,24 +49000,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
     },
     [1433] = {
         [sym__statement] = ACTIONS(SHIFT(1434)),
@@ -49033,33 +49033,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1434] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -49092,8 +49092,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_else] = ACTIONS(SHIFT(1539)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -49104,25 +49123,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(SHIFT(1539)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
     },
     [1435] = {
         [sym__statement] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -49155,8 +49155,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_rel_op] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_type_op] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym__statement, 1)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_regex] = ACTIONS(REDUCE(sym__statement, 1)),
@@ -49167,54 +49186,35 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym_false] = ACTIONS(REDUCE(sym__statement, 1)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym__statement, 1)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym__statement, 1)),
     },
     [1436] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1538)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1538)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1538)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
     [1437] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1538)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1538)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1538)),
     },
     [1438] = {
         [sym_var_assignment] = ACTIONS(SHIFT(1533)),
@@ -49224,22 +49224,22 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1439] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -49254,66 +49254,66 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [sym_pair] = ACTIONS(SHIFT(29)),
+        [sym_pair] = ACTIONS(SHIFT(32)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1469)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1530)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1531)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(1002)),
+        [sym_string] = ACTIONS(SHIFT(1029)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(1003)),
+        [sym_identifier] = ACTIONS(SHIFT(1030)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1470)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1531)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1440] = {
         [sym__paren_expression] = ACTIONS(SHIFT(1526)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
     },
     [1441] = {
         [sym__paren_expression] = ACTIONS(SHIFT(1521)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(826)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(800)),
     },
     [1442] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1485)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1485)),
     },
     [1443] = {
         [sym__paren_expression] = ACTIONS(SHIFT(1483)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(536)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(510)),
     },
     [1444] = {
         [sym_statement_block] = ACTIONS(SHIFT(1457)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1458)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1458)),
     },
     [1445] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
@@ -49332,24 +49332,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1455)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT(1455)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1455)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1446] = {
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
@@ -49368,92 +49368,92 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(31)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1447] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1451)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1451)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1451)),
     },
     [1448] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(198)),
-        [sym__expression] = ACTIONS(SHIFT(199)),
-        [sym_object] = ACTIONS(SHIFT(198)),
-        [sym_array] = ACTIONS(SHIFT(198)),
-        [sym_function_expression] = ACTIONS(SHIFT(198)),
-        [sym_function_call] = ACTIONS(SHIFT(198)),
-        [sym_constructor_call] = ACTIONS(SHIFT(198)),
+        [sym__paren_expression] = ACTIONS(SHIFT(226)),
+        [sym__expression] = ACTIONS(SHIFT(227)),
+        [sym_object] = ACTIONS(SHIFT(226)),
+        [sym_array] = ACTIONS(SHIFT(226)),
+        [sym_function_expression] = ACTIONS(SHIFT(226)),
+        [sym_function_call] = ACTIONS(SHIFT(226)),
+        [sym_constructor_call] = ACTIONS(SHIFT(226)),
         [sym_member_access] = ACTIONS(SHIFT(1449)),
         [sym_subscript_access] = ACTIONS(SHIFT(1449)),
-        [sym_assignment] = ACTIONS(SHIFT(198)),
-        [sym_math_assignment] = ACTIONS(SHIFT(198)),
-        [sym_ternary] = ACTIONS(SHIFT(198)),
-        [sym_bool_op] = ACTIONS(SHIFT(198)),
-        [sym_math_op] = ACTIONS(SHIFT(198)),
-        [sym_rel_op] = ACTIONS(SHIFT(198)),
-        [sym_type_op] = ACTIONS(SHIFT(198)),
+        [sym_assignment] = ACTIONS(SHIFT(226)),
+        [sym_math_assignment] = ACTIONS(SHIFT(226)),
+        [sym_ternary] = ACTIONS(SHIFT(226)),
+        [sym_bool_op] = ACTIONS(SHIFT(226)),
+        [sym_math_op] = ACTIONS(SHIFT(226)),
+        [sym_rel_op] = ACTIONS(SHIFT(226)),
+        [sym_type_op] = ACTIONS(SHIFT(226)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(229)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(230)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(231)),
+        [aux_sym_function] = ACTIONS(SHIFT(232)),
+        [aux_sym_new] = ACTIONS(SHIFT(233)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(234)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(235)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(198)),
-        [sym_regex] = ACTIONS(SHIFT(198)),
-        [sym_number] = ACTIONS(SHIFT(198)),
-        [sym_identifier] = ACTIONS(SHIFT(201)),
-        [sym_null] = ACTIONS(SHIFT(198)),
-        [sym_undefined] = ACTIONS(SHIFT(198)),
-        [sym_true] = ACTIONS(SHIFT(198)),
-        [sym_false] = ACTIONS(SHIFT(198)),
+        [sym_string] = ACTIONS(SHIFT(226)),
+        [sym_regex] = ACTIONS(SHIFT(226)),
+        [sym_number] = ACTIONS(SHIFT(226)),
+        [sym_identifier] = ACTIONS(SHIFT(236)),
+        [sym_null] = ACTIONS(SHIFT(226)),
+        [sym_undefined] = ACTIONS(SHIFT(226)),
+        [sym_true] = ACTIONS(SHIFT(226)),
+        [sym_false] = ACTIONS(SHIFT(226)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(202)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(203)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(204)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(205)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(206)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(207)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(208)),
     },
     [1449] = {
         [sym_arguments] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1450)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(238)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(239)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1450)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1450)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(211)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(212)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE(sym__expression, 1)),
     },
     [1450] = {
         [sym__statement] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -49487,8 +49487,49 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_delete_statement, 3)),
@@ -49499,47 +49540,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_delete_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_delete_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_delete_statement, 3)),
     },
     [1451] = {
         [sym__statement] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -49572,8 +49572,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_break_statement, 2)),
@@ -49584,50 +49604,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_break_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_break_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_break_statement, 2)),
     },
     [1452] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1453)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1453)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1453)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
     [1453] = {
         [sym__statement] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -49661,8 +49661,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_throw_statement, 3)),
@@ -49673,66 +49709,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_throw_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_throw_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_throw_statement, 3)),
     },
     [1454] = {
-        [sym_arguments] = ACTIONS(SHIFT(454)),
+        [sym_arguments] = ACTIONS(SHIFT(482)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1456)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(484)),
+        [aux_sym_in] = ACTIONS(SHIFT(27)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(474)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(475)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(485)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(486)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(487)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(488)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(488)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(489)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(489)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(490)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(490)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(491)),
+        [aux_sym_LT] = ACTIONS(SHIFT(491)),
+        [aux_sym_GT] = ACTIONS(SHIFT(491)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(27)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT(1456)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1456)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(456)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(457)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(446)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(447)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(458)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(459)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(460)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(461)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(462)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(463)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(464)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(457)),
     },
     [1455] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -49765,8 +49765,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 2)),
@@ -49777,26 +49797,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 2)),
     },
     [1456] = {
         [sym__statement] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -49830,8 +49830,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_return_statement, 3)),
@@ -49842,42 +49878,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_return_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_return_statement, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_return_statement, 3)),
     },
     [1457] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -49912,8 +49912,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_catch] = ACTIONS(SHIFT(1465)),
+        [aux_sym_finally] = ACTIONS(SHIFT(1466)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 2)),
@@ -49924,45 +49945,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_catch] = ACTIONS(SHIFT(1465)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(1466)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 2)),
     },
     [1458] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -49977,47 +49977,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1459)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1459)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1460)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1461)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1460)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1461)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1459] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1462)),
-    },
-    [1460] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1462)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1462)),
+    },
+    [1460] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1462)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1461] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -50052,8 +50052,29 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -50064,94 +50085,73 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1462] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_catch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_catch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1463] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -50185,8 +50185,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_finally] = ACTIONS(SHIFT(1466)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -50197,26 +50217,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_finally] = ACTIONS(SHIFT(1466)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
     [1464] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -50249,8 +50249,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 3)),
@@ -50261,36 +50280,17 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 3)),
     },
     [1465] = {
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(1473)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(1473)),
     },
     [1466] = {
         [sym_statement_block] = ACTIONS(SHIFT(1467)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1468)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1468)),
     },
     [1467] = {
         [sym__statement] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -50323,8 +50323,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_finally, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_finally, 2)),
@@ -50335,43 +50354,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_finally, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_finally, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_finally, 2)),
     },
     [1468] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -50386,47 +50386,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1469)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1469)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1470)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1471)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1470)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1471)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1469] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1472)),
-    },
-    [1470] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1472)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1472)),
+    },
+    [1470] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1472)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1471] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -50459,8 +50459,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -50471,88 +50490,69 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1472] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1473] = {
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1474)),
@@ -50561,15 +50561,15 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1474] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1475)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1475)),
     },
     [1475] = {
         [sym_statement_block] = ACTIONS(SHIFT(1476)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1477)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1477)),
     },
     [1476] = {
         [sym__statement] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -50603,8 +50603,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_catch, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_finally] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_catch, 5)),
@@ -50615,44 +50635,24 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_catch, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_catch, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_catch, 5)),
     },
     [1477] = {
-        [sym__statement] = ACTIONS(SHIFT(181)),
-        [sym_expression_statement] = ACTIONS(SHIFT(182)),
-        [sym_var_declaration] = ACTIONS(SHIFT(182)),
-        [sym_statement_block] = ACTIONS(SHIFT(182)),
-        [sym_if_statement] = ACTIONS(SHIFT(182)),
-        [sym_switch_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_statement] = ACTIONS(SHIFT(182)),
-        [sym_for_in_statement] = ACTIONS(SHIFT(182)),
-        [sym_while_statement] = ACTIONS(SHIFT(182)),
-        [sym_try_statement] = ACTIONS(SHIFT(182)),
-        [sym_return_statement] = ACTIONS(SHIFT(182)),
-        [sym_throw_statement] = ACTIONS(SHIFT(182)),
-        [sym_break_statement] = ACTIONS(SHIFT(182)),
-        [sym_delete_statement] = ACTIONS(SHIFT(182)),
+        [sym__statement] = ACTIONS(SHIFT(209)),
+        [sym_expression_statement] = ACTIONS(SHIFT(210)),
+        [sym_var_declaration] = ACTIONS(SHIFT(210)),
+        [sym_statement_block] = ACTIONS(SHIFT(210)),
+        [sym_if_statement] = ACTIONS(SHIFT(210)),
+        [sym_switch_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_statement] = ACTIONS(SHIFT(210)),
+        [sym_for_in_statement] = ACTIONS(SHIFT(210)),
+        [sym_while_statement] = ACTIONS(SHIFT(210)),
+        [sym_try_statement] = ACTIONS(SHIFT(210)),
+        [sym_return_statement] = ACTIONS(SHIFT(210)),
+        [sym_throw_statement] = ACTIONS(SHIFT(210)),
+        [sym_break_statement] = ACTIONS(SHIFT(210)),
+        [sym_delete_statement] = ACTIONS(SHIFT(210)),
         [sym__paren_expression] = ACTIONS(SHIFT(4)),
-        [sym__expression] = ACTIONS(SHIFT(183)),
+        [sym__expression] = ACTIONS(SHIFT(211)),
         [sym_object] = ACTIONS(SHIFT(4)),
         [sym_array] = ACTIONS(SHIFT(4)),
         [sym_function_expression] = ACTIONS(SHIFT(4)),
@@ -50667,47 +50667,47 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(1478)),
+        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1478)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(1479)),
+        [aux_sym_var] = ACTIONS(SHIFT(214)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(215)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1480)),
+        [aux_sym_if] = ACTIONS(SHIFT(217)),
+        [aux_sym_switch] = ACTIONS(SHIFT(218)),
+        [aux_sym_for] = ACTIONS(SHIFT(219)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(220)),
+        [aux_sym_try] = ACTIONS(SHIFT(221)),
+        [aux_sym_return] = ACTIONS(SHIFT(222)),
+        [aux_sym_throw] = ACTIONS(SHIFT(223)),
+        [aux_sym_break] = ACTIONS(SHIFT(224)),
+        [aux_sym_delete] = ACTIONS(SHIFT(225)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(SHIFT(1479)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(186)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(187)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1480)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(189)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(190)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(191)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(192)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(193)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(194)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(195)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(196)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(197)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1478] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1481)),
-    },
-    [1479] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1481)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1481)),
+    },
+    [1479] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1481)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1480] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -50741,8 +50741,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -50753,91 +50773,71 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1481] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym__expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_object] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_array] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_expression_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_var_declaration] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_statement_block] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_if_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_switch_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_for_in_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_while_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_try_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_return_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_throw_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_break_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_delete_statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__paren_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym__expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_object] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_array] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_expression] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_function_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_constructor_call] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_member_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_subscript_access] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_assignment] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_ternary] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_bool_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_finally] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_regex] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_number] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_null] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_true] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [sym_false] = ACTIONS(REDUCE(sym_statement_block, 3)),
+        [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_number] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_identifier] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_null] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_undefined] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_finally] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_statement_block, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_statement_block, 3)),
     },
     [1482] = {
         [sym__statement] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -50870,8 +50870,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_try_statement, 4)),
@@ -50882,25 +50901,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_try_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_try_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_try_statement, 4)),
     },
     [1483] = {
         [sym__statement] = ACTIONS(SHIFT(1484)),
@@ -50934,33 +50934,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1484] = {
         [sym__statement] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -50993,8 +50993,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_while_statement, 3)),
@@ -51005,231 +51024,204 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_while_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_while_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_while_statement, 3)),
     },
     [1485] = {
         [sym_var_declaration] = ACTIONS(SHIFT(1486)),
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
         [sym__expression] = ACTIONS(SHIFT(1487)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1486)),
+        [aux_sym_var] = ACTIONS(SHIFT(1488)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(1488)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(1489)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1486)),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1489)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [1486] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
         [sym__expression] = ACTIONS(SHIFT(1514)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1515)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1516)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1516)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [1487] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1499)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1499)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [1488] = {
-        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [sym_var_assignment] = ACTIONS(SHIFT(709)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(709)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_identifier] = ACTIONS(SHIFT(1494)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1495)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(533)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_DASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_STAR_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_SLASH_EQ] = ACTIONS(SHIFT(534)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
     },
     [1489] = {
-        [sym_var_assignment] = ACTIONS(SHIFT(600)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(600)),
+        [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_in] = ACTIONS(SHIFT(1490)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(557)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_DASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_STAR_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_SLASH_EQ] = ACTIONS(SHIFT(558)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym__expression, 1)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_identifier] = ACTIONS(SHIFT(1490)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1490] = {
+        [sym__paren_expression] = ACTIONS(SHIFT(593)),
+        [sym__expression] = ACTIONS(SHIFT(1491)),
+        [sym_object] = ACTIONS(SHIFT(593)),
+        [sym_array] = ACTIONS(SHIFT(593)),
+        [sym_function_expression] = ACTIONS(SHIFT(593)),
+        [sym_function_call] = ACTIONS(SHIFT(593)),
+        [sym_constructor_call] = ACTIONS(SHIFT(593)),
+        [sym_member_access] = ACTIONS(SHIFT(595)),
+        [sym_subscript_access] = ACTIONS(SHIFT(595)),
+        [sym_assignment] = ACTIONS(SHIFT(593)),
+        [sym_math_assignment] = ACTIONS(SHIFT(593)),
+        [sym_ternary] = ACTIONS(SHIFT(593)),
+        [sym_bool_op] = ACTIONS(SHIFT(593)),
+        [sym_math_op] = ACTIONS(SHIFT(593)),
+        [sym_rel_op] = ACTIONS(SHIFT(593)),
+        [sym_type_op] = ACTIONS(SHIFT(593)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(596)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(597)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(598)),
+        [aux_sym_function] = ACTIONS(SHIFT(599)),
+        [aux_sym_new] = ACTIONS(SHIFT(600)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(601)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(602)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(602)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(603)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(602)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(1491)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym_string] = ACTIONS(SHIFT(593)),
+        [sym_regex] = ACTIONS(SHIFT(593)),
+        [sym_number] = ACTIONS(SHIFT(593)),
+        [sym_identifier] = ACTIONS(SHIFT(603)),
+        [sym_null] = ACTIONS(SHIFT(593)),
+        [sym_undefined] = ACTIONS(SHIFT(593)),
+        [sym_true] = ACTIONS(SHIFT(593)),
+        [sym_false] = ACTIONS(SHIFT(593)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1491] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
-        [sym__expression] = ACTIONS(SHIFT(1492)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_arguments] = ACTIONS(SHIFT(608)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(609)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1492)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(610)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(611)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(615)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(615)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(616)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(616)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(617)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(617)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1492] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1493)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
-    },
-    [1493] = {
-        [sym__statement] = ACTIONS(SHIFT(1494)),
+        [sym__statement] = ACTIONS(SHIFT(1493)),
         [sym_expression_statement] = ACTIONS(SHIFT(1435)),
         [sym_var_declaration] = ACTIONS(SHIFT(1435)),
         [sym_statement_block] = ACTIONS(SHIFT(1435)),
@@ -51260,156 +51252,164 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
+    },
+    [1493] = {
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
     },
     [1494] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(711)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(712)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_in] = ACTIONS(SHIFT(1495)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__line_break] = ACTIONS(SHIFT(712)),
     },
     [1495] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(695)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1496)),
-        [sym_object] = ACTIONS(SHIFT(695)),
-        [sym_array] = ACTIONS(SHIFT(695)),
-        [sym_function_expression] = ACTIONS(SHIFT(695)),
-        [sym_function_call] = ACTIONS(SHIFT(695)),
-        [sym_constructor_call] = ACTIONS(SHIFT(695)),
-        [sym_member_access] = ACTIONS(SHIFT(697)),
-        [sym_subscript_access] = ACTIONS(SHIFT(697)),
-        [sym_assignment] = ACTIONS(SHIFT(695)),
-        [sym_math_assignment] = ACTIONS(SHIFT(695)),
-        [sym_ternary] = ACTIONS(SHIFT(695)),
-        [sym_bool_op] = ACTIONS(SHIFT(695)),
-        [sym_math_op] = ACTIONS(SHIFT(695)),
-        [sym_rel_op] = ACTIONS(SHIFT(695)),
-        [sym_type_op] = ACTIONS(SHIFT(695)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(695)),
-        [sym_regex] = ACTIONS(SHIFT(695)),
-        [sym_number] = ACTIONS(SHIFT(695)),
-        [sym_identifier] = ACTIONS(SHIFT(698)),
-        [sym_null] = ACTIONS(SHIFT(695)),
-        [sym_undefined] = ACTIONS(SHIFT(695)),
-        [sym_true] = ACTIONS(SHIFT(695)),
-        [sym_false] = ACTIONS(SHIFT(695)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(699)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(700)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(701)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(702)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(703)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(704)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(705)),
     },
     [1496] = {
-        [sym_arguments] = ACTIONS(SHIFT(707)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1497)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(708)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1497)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(709)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(710)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(711)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(762)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(763)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_type_op, 3)),
     },
     [1497] = {
         [sym__statement] = ACTIONS(SHIFT(1498)),
@@ -51443,228 +51443,228 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1498] = {
-        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym__statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_expression_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_var_declaration] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_statement_block] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_if_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_switch_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_for_in_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_while_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_try_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_return_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_throw_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_break_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_delete_statement] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__paren_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym__expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_object] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_array] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_expression] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_function_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_constructor_call] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_member_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_subscript_access] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_assignment] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_ternary] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_bool_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_math_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_rel_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_type_op] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
+        [sym_string] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_regex] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_number] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_identifier] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_null] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_undefined] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_true] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
+        [sym_false] = ACTIONS(REDUCE(sym_for_in_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_in_statement, 7)),
     },
     [1499] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(518)),
+        [sym__paren_expression] = ACTIONS(SHIFT(544)),
         [sym__expression] = ACTIONS(SHIFT(1500)),
-        [sym_object] = ACTIONS(SHIFT(518)),
-        [sym_array] = ACTIONS(SHIFT(518)),
-        [sym_function_expression] = ACTIONS(SHIFT(518)),
-        [sym_function_call] = ACTIONS(SHIFT(518)),
-        [sym_constructor_call] = ACTIONS(SHIFT(518)),
-        [sym_member_access] = ACTIONS(SHIFT(520)),
-        [sym_subscript_access] = ACTIONS(SHIFT(520)),
-        [sym_assignment] = ACTIONS(SHIFT(518)),
-        [sym_math_assignment] = ACTIONS(SHIFT(518)),
-        [sym_ternary] = ACTIONS(SHIFT(518)),
-        [sym_bool_op] = ACTIONS(SHIFT(518)),
-        [sym_math_op] = ACTIONS(SHIFT(518)),
-        [sym_rel_op] = ACTIONS(SHIFT(518)),
-        [sym_type_op] = ACTIONS(SHIFT(518)),
+        [sym_object] = ACTIONS(SHIFT(544)),
+        [sym_array] = ACTIONS(SHIFT(544)),
+        [sym_function_expression] = ACTIONS(SHIFT(544)),
+        [sym_function_call] = ACTIONS(SHIFT(544)),
+        [sym_constructor_call] = ACTIONS(SHIFT(544)),
+        [sym_member_access] = ACTIONS(SHIFT(546)),
+        [sym_subscript_access] = ACTIONS(SHIFT(546)),
+        [sym_assignment] = ACTIONS(SHIFT(544)),
+        [sym_math_assignment] = ACTIONS(SHIFT(544)),
+        [sym_ternary] = ACTIONS(SHIFT(544)),
+        [sym_bool_op] = ACTIONS(SHIFT(544)),
+        [sym_math_op] = ACTIONS(SHIFT(544)),
+        [sym_rel_op] = ACTIONS(SHIFT(544)),
+        [sym_type_op] = ACTIONS(SHIFT(544)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1501)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1502)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(548)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(549)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(550)),
+        [aux_sym_function] = ACTIONS(SHIFT(551)),
+        [aux_sym_new] = ACTIONS(SHIFT(552)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(553)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(554)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(518)),
-        [sym_regex] = ACTIONS(SHIFT(518)),
-        [sym_number] = ACTIONS(SHIFT(518)),
-        [sym_identifier] = ACTIONS(SHIFT(531)),
-        [sym_null] = ACTIONS(SHIFT(518)),
-        [sym_undefined] = ACTIONS(SHIFT(518)),
-        [sym_true] = ACTIONS(SHIFT(518)),
-        [sym_false] = ACTIONS(SHIFT(518)),
+        [sym_string] = ACTIONS(SHIFT(544)),
+        [sym_regex] = ACTIONS(SHIFT(544)),
+        [sym_number] = ACTIONS(SHIFT(544)),
+        [sym_identifier] = ACTIONS(SHIFT(560)),
+        [sym_null] = ACTIONS(SHIFT(544)),
+        [sym_undefined] = ACTIONS(SHIFT(544)),
+        [sym_true] = ACTIONS(SHIFT(544)),
+        [sym_false] = ACTIONS(SHIFT(544)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1502)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(523)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(524)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(525)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(526)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(527)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(528)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(529)),
     },
     [1500] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1509)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1509)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [1501] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1509)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1509)),
     },
     [1502] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1503)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1504)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1505)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1505)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1503] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1507)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1507)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1504] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1507)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1507)),
     },
     [1505] = {
         [sym__statement] = ACTIONS(SHIFT(1506)),
@@ -51698,33 +51698,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1506] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -51757,8 +51757,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 7)),
@@ -51769,25 +51788,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 7)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 7)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 7)),
     },
     [1507] = {
         [sym__statement] = ACTIONS(SHIFT(1508)),
@@ -51821,33 +51821,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1508] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -51880,8 +51880,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 8)),
@@ -51892,91 +51911,72 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 8)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 8)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 8)),
     },
     [1509] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1510)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1511)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1507)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1507)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1510] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1512)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1512)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1511] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1512)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1512)),
     },
     [1512] = {
         [sym__statement] = ACTIONS(SHIFT(1513)),
@@ -52010,33 +52010,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1513] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -52069,8 +52069,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 9)),
@@ -52081,120 +52100,101 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 9)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 9)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 9)),
     },
     [1514] = {
-        [sym_arguments] = ACTIONS(SHIFT(536)),
+        [sym_arguments] = ACTIONS(SHIFT(563)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1502)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(564)),
+        [aux_sym_in] = ACTIONS(SHIFT(561)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(565)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(566)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(582)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(583)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(584)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(567)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(567)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(568)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(568)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(569)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(569)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(585)),
+        [aux_sym_LT] = ACTIONS(SHIFT(585)),
+        [aux_sym_GT] = ACTIONS(SHIFT(585)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(561)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1502)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(537)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(532)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(538)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(539)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(540)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(541)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(542)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(543)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(544)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(545)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(546)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(532)),
     },
     [1515] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1502)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1502)),
     },
     [1516] = {
-        [sym__paren_expression] = ACTIONS(SHIFT(340)),
+        [sym__paren_expression] = ACTIONS(SHIFT(372)),
         [sym__expression] = ACTIONS(SHIFT(1517)),
-        [sym_object] = ACTIONS(SHIFT(340)),
-        [sym_array] = ACTIONS(SHIFT(340)),
-        [sym_function_expression] = ACTIONS(SHIFT(340)),
-        [sym_function_call] = ACTIONS(SHIFT(340)),
-        [sym_constructor_call] = ACTIONS(SHIFT(340)),
-        [sym_member_access] = ACTIONS(SHIFT(342)),
-        [sym_subscript_access] = ACTIONS(SHIFT(342)),
-        [sym_assignment] = ACTIONS(SHIFT(340)),
-        [sym_math_assignment] = ACTIONS(SHIFT(340)),
-        [sym_ternary] = ACTIONS(SHIFT(340)),
-        [sym_bool_op] = ACTIONS(SHIFT(340)),
-        [sym_math_op] = ACTIONS(SHIFT(340)),
-        [sym_rel_op] = ACTIONS(SHIFT(340)),
-        [sym_type_op] = ACTIONS(SHIFT(340)),
+        [sym_object] = ACTIONS(SHIFT(372)),
+        [sym_array] = ACTIONS(SHIFT(372)),
+        [sym_function_expression] = ACTIONS(SHIFT(372)),
+        [sym_function_call] = ACTIONS(SHIFT(372)),
+        [sym_constructor_call] = ACTIONS(SHIFT(372)),
+        [sym_member_access] = ACTIONS(SHIFT(374)),
+        [sym_subscript_access] = ACTIONS(SHIFT(374)),
+        [sym_assignment] = ACTIONS(SHIFT(372)),
+        [sym_math_assignment] = ACTIONS(SHIFT(372)),
+        [sym_ternary] = ACTIONS(SHIFT(372)),
+        [sym_bool_op] = ACTIONS(SHIFT(372)),
+        [sym_math_op] = ACTIONS(SHIFT(372)),
+        [sym_rel_op] = ACTIONS(SHIFT(372)),
+        [sym_type_op] = ACTIONS(SHIFT(372)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1518)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(376)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(377)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1519)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(378)),
+        [aux_sym_function] = ACTIONS(SHIFT(379)),
+        [aux_sym_new] = ACTIONS(SHIFT(380)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(381)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(382)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym_string] = ACTIONS(SHIFT(340)),
-        [sym_regex] = ACTIONS(SHIFT(340)),
-        [sym_number] = ACTIONS(SHIFT(340)),
-        [sym_identifier] = ACTIONS(SHIFT(344)),
-        [sym_null] = ACTIONS(SHIFT(340)),
-        [sym_undefined] = ACTIONS(SHIFT(340)),
-        [sym_true] = ACTIONS(SHIFT(340)),
-        [sym_false] = ACTIONS(SHIFT(340)),
+        [sym_string] = ACTIONS(SHIFT(372)),
+        [sym_regex] = ACTIONS(SHIFT(372)),
+        [sym_number] = ACTIONS(SHIFT(372)),
+        [sym_identifier] = ACTIONS(SHIFT(383)),
+        [sym_null] = ACTIONS(SHIFT(372)),
+        [sym_undefined] = ACTIONS(SHIFT(372)),
+        [sym_true] = ACTIONS(SHIFT(372)),
+        [sym_false] = ACTIONS(SHIFT(372)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(345)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(346)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1519)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(347)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(348)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(349)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(350)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(351)),
     },
     [1517] = {
-        [sym_arguments] = ACTIONS(SHIFT(353)),
+        [sym_arguments] = ACTIONS(SHIFT(388)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(389)),
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1505)),
+        [aux_sym_in] = ACTIONS(SHIFT(384)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(390)),
+        [aux_sym_DOT] = ACTIONS(SHIFT(391)),
+        [aux_sym_QMARK] = ACTIONS(SHIFT(392)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(SHIFT(393)),
+        [aux_sym_AMP_AMP] = ACTIONS(SHIFT(394)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(SHIFT(395)),
+        [aux_sym_DASH_DASH] = ACTIONS(SHIFT(395)),
+        [aux_sym_STAR] = ACTIONS(SHIFT(396)),
+        [aux_sym_SLASH] = ACTIONS(SHIFT(396)),
+        [aux_sym_PLUS] = ACTIONS(SHIFT(397)),
+        [aux_sym_DASH] = ACTIONS(SHIFT(397)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(SHIFT(398)),
+        [aux_sym_LT] = ACTIONS(SHIFT(398)),
+        [aux_sym_GT] = ACTIONS(SHIFT(398)),
+        [aux_sym_instanceof] = ACTIONS(SHIFT(384)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(354)),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1505)),
-        [aux_sym_STR_in] = ACTIONS(SHIFT(396)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(355)),
-        [aux_sym_STR_DOT] = ACTIONS(SHIFT(356)),
-        [aux_sym_STR_QMARK] = ACTIONS(SHIFT(397)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(SHIFT(398)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(SHIFT(399)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(SHIFT(357)),
-        [aux_sym_STR_STAR] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_SLASH] = ACTIONS(SHIFT(400)),
-        [aux_sym_STR_PLUS] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_DASH] = ACTIONS(SHIFT(401)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_LT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_GT] = ACTIONS(SHIFT(402)),
-        [aux_sym_STR_instanceof] = ACTIONS(SHIFT(396)),
     },
     [1518] = {
+        [aux_sym_RPAREN] = ACTIONS(SHIFT(1505)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RPAREN] = ACTIONS(SHIFT(1505)),
     },
     [1519] = {
         [sym__statement] = ACTIONS(SHIFT(1520)),
@@ -52228,33 +52228,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1520] = {
         [sym__statement] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -52287,8 +52287,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_type_op] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_regex] = ACTIONS(REDUCE(sym_for_statement, 6)),
@@ -52299,45 +52318,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym_false] = ACTIONS(REDUCE(sym_for_statement, 6)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_for_statement, 6)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_for_statement, 6)),
     },
     [1521] = {
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1522)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1522)),
     },
     [1522] = {
-        [sym_case] = ACTIONS(SHIFT(805)),
-        [sym_default] = ACTIONS(SHIFT(805)),
+        [sym_case] = ACTIONS(SHIFT(831)),
+        [sym_default] = ACTIONS(SHIFT(831)),
+        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1523)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1524)),
+        [aux_sym_case] = ACTIONS(SHIFT(834)),
+        [aux_sym_default] = ACTIONS(SHIFT(835)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_switch_statement_repeat1] = ACTIONS(SHIFT(1523)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1524)),
-        [aux_sym_STR_case] = ACTIONS(SHIFT(808)),
-        [aux_sym_STR_default] = ACTIONS(SHIFT(809)),
     },
     [1523] = {
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1525)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1525)),
     },
     [1524] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -52370,8 +52370,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 4)),
@@ -52382,25 +52401,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 4)),
     },
     [1525] = {
         [sym__statement] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -52433,8 +52433,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_switch_statement, 5)),
@@ -52445,25 +52464,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_switch_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_switch_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_switch_statement, 5)),
     },
     [1526] = {
         [sym__statement] = ACTIONS(SHIFT(1527)),
@@ -52497,33 +52497,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1527] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -52556,8 +52556,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_else] = ACTIONS(SHIFT(1528)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
@@ -52568,25 +52587,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_else] = ACTIONS(SHIFT(1528)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_if_statement, 3)),
     },
     [1528] = {
         [sym__statement] = ACTIONS(SHIFT(1529)),
@@ -52620,33 +52620,33 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(1437)),
+        [aux_sym_var] = ACTIONS(SHIFT(1438)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(1439)),
+        [aux_sym_if] = ACTIONS(SHIFT(1440)),
+        [aux_sym_switch] = ACTIONS(SHIFT(1441)),
+        [aux_sym_for] = ACTIONS(SHIFT(1442)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(1443)),
+        [aux_sym_try] = ACTIONS(SHIFT(1444)),
+        [aux_sym_return] = ACTIONS(SHIFT(1445)),
+        [aux_sym_throw] = ACTIONS(SHIFT(1446)),
+        [aux_sym_break] = ACTIONS(SHIFT(1447)),
+        [aux_sym_delete] = ACTIONS(SHIFT(1448)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(1438)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(1439)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(1440)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(1441)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(1442)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(1443)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(1444)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(1445)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(1446)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(1447)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(1448)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1529] = {
         [sym__statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -52679,8 +52679,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -52691,33 +52710,14 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
     },
     [1530] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1031)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1532)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1009)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1532)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1531] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -52751,8 +52751,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -52763,42 +52799,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1532] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -52832,8 +52832,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -52844,59 +52880,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
     },
     [1533] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1535)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1536)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1535)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1536)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1535)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
+        [sym__line_break] = ACTIONS(SHIFT(1536)),
     },
     [1534] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1535)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1536)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1535)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1536)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1535)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym__line_break] = ACTIONS(SHIFT(1536)),
     },
     [1535] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1537)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1537)),
+    },
+    [1536] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -52927,8 +52932,31 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -52939,34 +52967,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-    },
-    [1536] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1537)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1537)),
     },
     [1537] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -52999,8 +52999,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -53011,26 +53031,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
     },
     [1538] = {
         [sym__statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -53064,8 +53064,44 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_else] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -53076,42 +53112,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_else] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
     },
     [1539] = {
         [sym__statement] = ACTIONS(SHIFT(1540)),
@@ -53144,34 +53144,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(SHIFT(4)),
         [sym_rel_op] = ACTIONS(SHIFT(4)),
         [sym_type_op] = ACTIONS(SHIFT(4)),
-        [ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
+        [ts_builtin_sym_error] = ACTIONS(SHIFT(8)),
+        [aux_sym_var] = ACTIONS(SHIFT(9)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(10)),
+        [aux_sym_if] = ACTIONS(SHIFT(11)),
+        [aux_sym_switch] = ACTIONS(SHIFT(12)),
+        [aux_sym_for] = ACTIONS(SHIFT(13)),
+        [aux_sym_LPAREN] = ACTIONS(SHIFT(14)),
+        [aux_sym_while] = ACTIONS(SHIFT(15)),
+        [aux_sym_try] = ACTIONS(SHIFT(16)),
+        [aux_sym_return] = ACTIONS(SHIFT(17)),
+        [aux_sym_throw] = ACTIONS(SHIFT(18)),
+        [aux_sym_break] = ACTIONS(SHIFT(19)),
+        [aux_sym_delete] = ACTIONS(SHIFT(20)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(21)),
+        [aux_sym_function] = ACTIONS(SHIFT(22)),
+        [aux_sym_new] = ACTIONS(SHIFT(23)),
+        [aux_sym_BANG] = ACTIONS(SHIFT(24)),
+        [aux_sym_typeof] = ACTIONS(SHIFT(25)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(SHIFT(4)),
         [sym_regex] = ACTIONS(SHIFT(4)),
         [sym_number] = ACTIONS(SHIFT(4)),
-        [sym_identifier] = ACTIONS(SHIFT(8)),
+        [sym_identifier] = ACTIONS(SHIFT(26)),
         [sym_null] = ACTIONS(SHIFT(4)),
         [sym_undefined] = ACTIONS(SHIFT(4)),
         [sym_true] = ACTIONS(SHIFT(4)),
         [sym_false] = ACTIONS(SHIFT(4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_STR_var] = ACTIONS(SHIFT(10)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(11)),
-        [aux_sym_STR_if] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_switch] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_for] = ACTIONS(SHIFT(14)),
-        [aux_sym_STR_LPAREN] = ACTIONS(SHIFT(15)),
-        [aux_sym_STR_while] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_try] = ACTIONS(SHIFT(17)),
-        [aux_sym_STR_return] = ACTIONS(SHIFT(18)),
-        [aux_sym_STR_throw] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_break] = ACTIONS(SHIFT(20)),
-        [aux_sym_STR_delete] = ACTIONS(SHIFT(21)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(22)),
-        [aux_sym_STR_function] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_new] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_BANG] = ACTIONS(SHIFT(25)),
-        [aux_sym_STR_typeof] = ACTIONS(SHIFT(26)),
     },
     [1540] = {
         [sym__statement] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -53204,8 +53204,26 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_type_op] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_regex] = ACTIONS(REDUCE(sym_if_statement, 5)),
@@ -53216,32 +53234,14 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym_false] = ACTIONS(REDUCE(sym_if_statement, 5)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_if_statement, 5)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_if_statement, 5)),
     },
     [1541] = {
+        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1031)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(287)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(451)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(1543)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(259)),
-        [aux_sym_object_repeat1] = ACTIONS(SHIFT(1009)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(259)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(415)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(1543)),
+        [sym__line_break] = ACTIONS(SHIFT(287)),
     },
     [1542] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -53275,8 +53275,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
@@ -53287,41 +53322,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 2)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 2)),
     },
     [1543] = {
         [sym__statement] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -53355,8 +53355,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_type_op] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_arguments] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_regex] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
@@ -53367,58 +53402,28 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym_false] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
         [sym__line_break] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_FRAGILE(sym_object, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE_FRAGILE(sym_statement_block, 3)),
     },
     [1544] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1546)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1547)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1546)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1547)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1546)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
+        [sym__line_break] = ACTIONS(SHIFT(1547)),
     },
     [1545] = {
+        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1546)),
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1547)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(713)),
+        [aux_sym_EQ] = ACTIONS(SHIFT(715)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1546)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(SHIFT(1547)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1546)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(604)),
-        [aux_sym_STR_EQ] = ACTIONS(SHIFT(606)),
+        [sym__line_break] = ACTIONS(SHIFT(1547)),
     },
     [1546] = {
+        [aux_sym_SEMI] = ACTIONS(SHIFT(1548)),
+        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
+        [sym__line_break] = ACTIONS(SHIFT(1548)),
+    },
+    [1547] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_expression_statement] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_var_declaration] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -53449,8 +53454,30 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 3)),
@@ -53461,33 +53488,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 3)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_var_declaration_repeat1] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 3)),
-    },
-    [1547] = {
-        [sym_comment] = ACTIONS(SHIFT_EXTRA()),
-        [sym__line_break] = ACTIONS(SHIFT(1548)),
-        [aux_sym_STR_SEMI] = ACTIONS(SHIFT(1548)),
     },
     [1548] = {
         [sym__statement] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -53520,8 +53520,27 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_math_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_rel_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_type_op] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_regex] = ACTIONS(REDUCE(sym_var_declaration, 4)),
@@ -53532,25 +53551,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym_false] = ACTIONS(REDUCE(sym_var_declaration, 4)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_var_declaration, 4)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_var_declaration, 4)),
     },
     [1549] = {
         [sym__statement] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -53584,8 +53584,43 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_rel_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_type_op] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_arguments] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [ts_builtin_sym_error] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
+        [aux_sym_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
+        [aux_sym_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_comment] = ACTIONS(SHIFT_EXTRA()),
         [sym_string] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_regex] = ACTIONS(REDUCE(sym_expression_statement, 2)),
@@ -53596,41 +53631,6 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym_true] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym_false] = ACTIONS(REDUCE(sym_expression_statement, 2)),
         [sym__line_break] = ACTIONS(SHIFT_EXTRA()),
-        [aux_sym_program_repeat1] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_SEMI] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_var] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_if] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_switch] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_for] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LPAREN] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_in] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_while] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_try] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_return] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_throw] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_break] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_delete] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_LBRACK] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_function] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_new] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_DOT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_QMARK] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PIPE_PIPE] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_AMP_AMP] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG] = ACTIONS(REDUCE(sym_expression_statement, 2)),
-        [aux_sym_STR_PLUS_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_STAR] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_SLASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_PLUS] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_DASH] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_EQ_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_BANG_EQ_EQ] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_LT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_GT] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_instanceof] = ACTIONS(REDUCE_EXTRA(sym__line_break)),
-        [aux_sym_STR_typeof] = ACTIONS(REDUCE(sym_expression_statement, 2)),
     },
     [1550] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(aux_sym_program_repeat1, 2)),
diff --git a/spec/fixtures/parsers/json.c b/spec/fixtures/parsers/json.c
index 95bab04a..ab6c1c6c 100644
--- a/spec/fixtures/parsers/json.c
+++ b/spec/fixtures/parsers/json.c
@@ -7,52 +7,52 @@ enum {
     sym__value = ts_builtin_sym_start,
     sym_object,
     sym_array,
+    aux_sym_object_repeat1,
+    aux_sym_array_repeat1,
+    aux_sym_LBRACE,
+    aux_sym_COLON,
+    aux_sym_COMMA,
+    aux_sym_RBRACE,
+    aux_sym_LBRACK,
+    aux_sym_RBRACK,
     sym_string,
     sym_number,
     sym_null,
     sym_true,
     sym_false,
-    aux_sym_object_repeat1,
-    aux_sym_array_repeat1,
-    aux_sym_STR_LBRACE,
-    aux_sym_STR_COLON,
-    aux_sym_STR_COMMA,
-    aux_sym_STR_RBRACE,
-    aux_sym_STR_LBRACK,
-    aux_sym_STR_RBRACK,
 };
 
 static const char *ts_symbol_names[] = {
     [sym__value] = "_value",
     [sym_object] = "object",
     [sym_array] = "array",
+    [aux_sym_object_repeat1] = "object_repeat1",
+    [aux_sym_array_repeat1] = "array_repeat1",
     [ts_builtin_sym_error] = "ERROR",
     [ts_builtin_sym_end] = "END",
+    [aux_sym_LBRACE] = "{",
+    [aux_sym_COLON] = ":",
+    [aux_sym_COMMA] = ",",
+    [aux_sym_RBRACE] = "}",
+    [aux_sym_LBRACK] = "[",
+    [aux_sym_RBRACK] = "]",
     [sym_string] = "string",
     [sym_number] = "number",
     [sym_null] = "null",
     [sym_true] = "true",
     [sym_false] = "false",
-    [aux_sym_object_repeat1] = "object_repeat1",
-    [aux_sym_array_repeat1] = "array_repeat1",
-    [aux_sym_STR_LBRACE] = "STR_{",
-    [aux_sym_STR_COLON] = "STR_:",
-    [aux_sym_STR_COMMA] = "STR_,",
-    [aux_sym_STR_RBRACE] = "STR_}",
-    [aux_sym_STR_LBRACK] = "STR_[",
-    [aux_sym_STR_RBRACK] = "STR_]",
 };
 
 static const int ts_hidden_symbol_flags[SYMBOL_COUNT] = {
     [sym__value] = 1,
     [aux_sym_object_repeat1] = 1,
     [aux_sym_array_repeat1] = 1,
-    [aux_sym_STR_LBRACE] = 1,
-    [aux_sym_STR_COLON] = 1,
-    [aux_sym_STR_COMMA] = 1,
-    [aux_sym_STR_RBRACE] = 1,
-    [aux_sym_STR_LBRACK] = 1,
-    [aux_sym_STR_RBRACK] = 1,
+    [aux_sym_LBRACE] = 1,
+    [aux_sym_COLON] = 1,
+    [aux_sym_COMMA] = 1,
+    [aux_sym_RBRACE] = 1,
+    [aux_sym_LBRACK] = 1,
+    [aux_sym_RBRACK] = 1,
 };
 
 static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@@ -127,7 +127,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(8);
             ACCEPT_TOKEN(sym_number);
         case 9:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACK);
+            ACCEPT_TOKEN(aux_sym_LBRACK);
         case 10:
             if (lookahead == 'a')
                 ADVANCE(11);
@@ -175,7 +175,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
         case 22:
             ACCEPT_TOKEN(sym_true);
         case 23:
-            ACCEPT_TOKEN(aux_sym_STR_LBRACE);
+            ACCEPT_TOKEN(aux_sym_LBRACE);
         case 24:
             START_TOKEN();
             if (lookahead == 0)
@@ -201,7 +201,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(27);
             LEX_ERROR();
         case 27:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACE);
+            ACCEPT_TOKEN(aux_sym_RBRACE);
         case 28:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -227,7 +227,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(23);
             LEX_ERROR();
         case 29:
-            ACCEPT_TOKEN(aux_sym_STR_RBRACK);
+            ACCEPT_TOKEN(aux_sym_RBRACK);
         case 30:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -241,7 +241,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(29);
             LEX_ERROR();
         case 31:
-            ACCEPT_TOKEN(aux_sym_STR_COMMA);
+            ACCEPT_TOKEN(aux_sym_COMMA);
         case 32:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -275,7 +275,7 @@ static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
                 ADVANCE(35);
             LEX_ERROR();
         case 35:
-            ACCEPT_TOKEN(aux_sym_STR_COLON);
+            ACCEPT_TOKEN(aux_sym_COLON);
         case 36:
             START_TOKEN();
             if ((lookahead == '\t') ||
@@ -385,8 +385,8 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [16] = 32,
     [17] = 30,
     [18] = 33,
-    [19] = 34,
-    [20] = 30,
+    [19] = 30,
+    [20] = 34,
     [21] = 1,
     [22] = 33,
     [23] = 33,
@@ -398,8 +398,8 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [29] = 33,
     [30] = 33,
     [31] = 33,
-    [32] = 34,
-    [33] = 33,
+    [32] = 33,
+    [33] = 34,
     [34] = 1,
     [35] = 33,
     [36] = 36,
@@ -425,8 +425,8 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
     [56] = 24,
     [57] = 24,
     [58] = 33,
-    [59] = 34,
-    [60] = 24,
+    [59] = 24,
+    [60] = 34,
     [61] = 1,
     [62] = 33,
     [63] = 36,
@@ -445,13 +445,13 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [sym__value] = ACTIONS(SHIFT(1)),
         [sym_object] = ACTIONS(SHIFT(2)),
         [sym_array] = ACTIONS(SHIFT(2)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(3)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(4)),
         [sym_string] = ACTIONS(SHIFT(2)),
         [sym_number] = ACTIONS(SHIFT(2)),
         [sym_null] = ACTIONS(SHIFT(2)),
         [sym_true] = ACTIONS(SHIFT(2)),
         [sym_false] = ACTIONS(SHIFT(2)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(3)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(4)),
     },
     [1] = {
         [ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
@@ -461,208 +461,208 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [3] = {
         [ts_builtin_sym_error] = ACTIONS(SHIFT(58)),
-        [sym_string] = ACTIONS(SHIFT(59)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(60)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(59)),
+        [sym_string] = ACTIONS(SHIFT(60)),
     },
     [4] = {
         [sym__value] = ACTIONS(SHIFT(5)),
         [sym_object] = ACTIONS(SHIFT(6)),
         [sym_array] = ACTIONS(SHIFT(6)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(5)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(7)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(8)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(9)),
         [sym_string] = ACTIONS(SHIFT(6)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_null] = ACTIONS(SHIFT(6)),
         [sym_true] = ACTIONS(SHIFT(6)),
         [sym_false] = ACTIONS(SHIFT(6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(9)),
     },
     [5] = {
         [aux_sym_array_repeat1] = ACTIONS(SHIFT(55)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(56)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(13)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(56)),
     },
     [6] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__value, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym__value, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym__value, 1)),
     },
     [7] = {
         [ts_builtin_sym_error] = ACTIONS(SHIFT(18)),
-        [sym_string] = ACTIONS(SHIFT(19)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(20)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(19)),
+        [sym_string] = ACTIONS(SHIFT(20)),
     },
     [8] = {
         [sym__value] = ACTIONS(SHIFT(10)),
         [sym_object] = ACTIONS(SHIFT(6)),
         [sym_array] = ACTIONS(SHIFT(6)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(10)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(7)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(8)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(11)),
         [sym_string] = ACTIONS(SHIFT(6)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_null] = ACTIONS(SHIFT(6)),
         [sym_true] = ACTIONS(SHIFT(6)),
         [sym_false] = ACTIONS(SHIFT(6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(11)),
     },
     [9] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [10] = {
         [aux_sym_array_repeat1] = ACTIONS(SHIFT(12)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(14)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(13)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(14)),
     },
     [11] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [12] = {
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(17)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(17)),
     },
     [13] = {
         [sym__value] = ACTIONS(SHIFT(15)),
         [sym_object] = ACTIONS(SHIFT(6)),
         [sym_array] = ACTIONS(SHIFT(6)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(15)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(7)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(8)),
         [sym_string] = ACTIONS(SHIFT(6)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_null] = ACTIONS(SHIFT(6)),
         [sym_true] = ACTIONS(SHIFT(6)),
         [sym_false] = ACTIONS(SHIFT(6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(8)),
     },
     [14] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [15] = {
         [aux_sym_array_repeat1] = ACTIONS(SHIFT(16)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(13)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
     },
     [16] = {
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3)),
     },
     [17] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [18] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(52)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(53)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(53)),
     },
     [19] = {
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(21)),
+        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 2)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 2)),
     },
     [20] = {
-        [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 2)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 2)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(21)),
     },
     [21] = {
         [sym__value] = ACTIONS(SHIFT(22)),
         [sym_object] = ACTIONS(SHIFT(23)),
         [sym_array] = ACTIONS(SHIFT(23)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(24)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(25)),
         [sym_string] = ACTIONS(SHIFT(23)),
         [sym_number] = ACTIONS(SHIFT(23)),
         [sym_null] = ACTIONS(SHIFT(23)),
         [sym_true] = ACTIONS(SHIFT(23)),
         [sym_false] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(25)),
     },
     [22] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(49)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(50)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(50)),
     },
     [23] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__value, 1)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym__value, 1)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym__value, 1)),
     },
     [24] = {
         [ts_builtin_sym_error] = ACTIONS(SHIFT(31)),
-        [sym_string] = ACTIONS(SHIFT(32)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(33)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(32)),
+        [sym_string] = ACTIONS(SHIFT(33)),
     },
     [25] = {
         [sym__value] = ACTIONS(SHIFT(26)),
         [sym_object] = ACTIONS(SHIFT(6)),
         [sym_array] = ACTIONS(SHIFT(6)),
         [ts_builtin_sym_error] = ACTIONS(SHIFT(26)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(7)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(8)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(27)),
         [sym_string] = ACTIONS(SHIFT(6)),
         [sym_number] = ACTIONS(SHIFT(6)),
         [sym_null] = ACTIONS(SHIFT(6)),
         [sym_true] = ACTIONS(SHIFT(6)),
         [sym_false] = ACTIONS(SHIFT(6)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(7)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(8)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(27)),
     },
     [26] = {
         [aux_sym_array_repeat1] = ACTIONS(SHIFT(28)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(13)),
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(29)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(13)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(29)),
     },
     [27] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 2)),
     },
     [28] = {
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(30)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(30)),
     },
     [29] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 3)),
     },
     [30] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 4)),
     },
     [31] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(46)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(47)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(47)),
     },
     [32] = {
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(34)),
+        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 2)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 2)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 2)),
     },
     [33] = {
-        [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 2)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 2)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 2)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(34)),
     },
     [34] = {
         [sym__value] = ACTIONS(SHIFT(35)),
         [sym_object] = ACTIONS(SHIFT(23)),
         [sym_array] = ACTIONS(SHIFT(23)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(24)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(25)),
         [sym_string] = ACTIONS(SHIFT(23)),
         [sym_number] = ACTIONS(SHIFT(23)),
         [sym_null] = ACTIONS(SHIFT(23)),
         [sym_true] = ACTIONS(SHIFT(23)),
         [sym_false] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(25)),
     },
     [35] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(36)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(38)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(38)),
     },
     [36] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(45)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(45)),
     },
     [37] = {
         [ts_builtin_sym_error] = ACTIONS(SHIFT(39)),
@@ -670,86 +670,86 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [38] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 5)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 5)),
     },
     [39] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(44)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 2)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 2)),
     },
     [40] = {
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(41)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(41)),
     },
     [41] = {
         [sym__value] = ACTIONS(SHIFT(42)),
         [sym_object] = ACTIONS(SHIFT(23)),
         [sym_array] = ACTIONS(SHIFT(23)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(24)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(25)),
         [sym_string] = ACTIONS(SHIFT(23)),
         [sym_number] = ACTIONS(SHIFT(23)),
         [sym_null] = ACTIONS(SHIFT(23)),
         [sym_true] = ACTIONS(SHIFT(23)),
         [sym_false] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(25)),
     },
     [42] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(43)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 4)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 4)),
     },
     [43] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 5)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 5)),
     },
     [44] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 3)),
     },
     [45] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 6)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 6)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 6)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 6)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 6)),
     },
     [46] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(48)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(48)),
     },
     [47] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [48] = {
         [aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RBRACE] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [49] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(51)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(51)),
     },
     [50] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 5)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 5)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 5)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 5)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 5)),
     },
     [51] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 6)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 6)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 6)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 6)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 6)),
     },
     [52] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(54)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(54)),
     },
     [53] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 3)),
     },
     [54] = {
         [aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
-        [aux_sym_STR_RBRACK] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
+        [aux_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 4)),
     },
     [55] = {
-        [aux_sym_STR_RBRACK] = ACTIONS(SHIFT(57)),
+        [aux_sym_RBRACK] = ACTIONS(SHIFT(57)),
     },
     [56] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 3)),
@@ -759,34 +759,34 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
     },
     [58] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(66)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(67)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(67)),
     },
     [59] = {
-        [aux_sym_STR_COLON] = ACTIONS(SHIFT(61)),
+        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 2)),
     },
     [60] = {
-        [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 2)),
+        [aux_sym_COLON] = ACTIONS(SHIFT(61)),
     },
     [61] = {
         [sym__value] = ACTIONS(SHIFT(62)),
         [sym_object] = ACTIONS(SHIFT(23)),
         [sym_array] = ACTIONS(SHIFT(23)),
+        [aux_sym_LBRACE] = ACTIONS(SHIFT(24)),
+        [aux_sym_LBRACK] = ACTIONS(SHIFT(25)),
         [sym_string] = ACTIONS(SHIFT(23)),
         [sym_number] = ACTIONS(SHIFT(23)),
         [sym_null] = ACTIONS(SHIFT(23)),
         [sym_true] = ACTIONS(SHIFT(23)),
         [sym_false] = ACTIONS(SHIFT(23)),
-        [aux_sym_STR_LBRACE] = ACTIONS(SHIFT(24)),
-        [aux_sym_STR_LBRACK] = ACTIONS(SHIFT(25)),
     },
     [62] = {
         [aux_sym_object_repeat1] = ACTIONS(SHIFT(63)),
-        [aux_sym_STR_COMMA] = ACTIONS(SHIFT(37)),
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(64)),
+        [aux_sym_COMMA] = ACTIONS(SHIFT(37)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(64)),
     },
     [63] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(65)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(65)),
     },
     [64] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 5)),
@@ -795,7 +795,7 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 6)),
     },
     [66] = {
-        [aux_sym_STR_RBRACE] = ACTIONS(SHIFT(68)),
+        [aux_sym_RBRACE] = ACTIONS(SHIFT(68)),
     },
     [67] = {
         [ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 3)),
diff --git a/src/compiler/build_tables/build_lex_table.cc b/src/compiler/build_tables/build_lex_table.cc
index 3be9ee3a..bab0497f 100644
--- a/src/compiler/build_tables/build_lex_table.cc
+++ b/src/compiler/build_tables/build_lex_table.cc
@@ -10,7 +10,7 @@
 #include "compiler/build_tables/get_metadata.h"
 #include "compiler/build_tables/lex_item.h"
 #include "compiler/parse_table.h"
-#include "compiler/lexical_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/built_in_symbols.h"
 #include "compiler/rules/choice.h"
 #include "compiler/rules/metadata.h"
@@ -63,9 +63,9 @@ class LexTableBuilder {
         result.insert(
           LexItem(symbol, after_separators(CharacterSet().include(0).copy())));
 
-      else if (symbol.is_token())
-        result.insert(
-          LexItem(symbol, after_separators(lex_grammar.rule(symbol))));
+      else if (symbol.is_token)
+        result.insert(LexItem(
+          symbol, after_separators(lex_grammar.rules[symbol.index].rule)));
     }
     return result;
   }
diff --git a/src/compiler/build_tables/build_parse_table.cc b/src/compiler/build_tables/build_parse_table.cc
index 3a72804e..9d6c42f0 100644
--- a/src/compiler/build_tables/build_parse_table.cc
+++ b/src/compiler/build_tables/build_parse_table.cc
@@ -11,8 +11,7 @@
 #include "compiler/build_tables/parse_item.h"
 #include "compiler/build_tables/get_completion_status.h"
 #include "compiler/build_tables/get_metadata.h"
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/symbol.h"
 #include "compiler/rules/built_in_symbols.h"
 
@@ -48,9 +47,8 @@ class ParseTableBuilder {
         conflict_manager(grammar) {}
 
   pair<ParseTable, const GrammarError *> build() {
-    auto start_symbol = grammar.rules.empty()
-                          ? make_shared<Symbol>(0, rules::SymbolOptionToken)
-                          : make_shared<Symbol>(0);
+    auto start_symbol = grammar.rules.empty() ? make_shared<Symbol>(0, true)
+                                              : make_shared<Symbol>(0);
     ParseItem start_item(rules::START(), start_symbol, {});
     add_parse_state(
       item_set_closure(start_item, { rules::END_OF_INPUT() }, grammar));
@@ -260,10 +258,10 @@ class ParseTableBuilder {
         return "END_OF_INPUT";
       else
         return "";
-    } else if (symbol.is_token())
-      return lexical_grammar.rule_name(symbol);
+    } else if (symbol.is_token)
+      return lexical_grammar.rules[symbol.index].name;
     else
-      return grammar.rule_name(symbol);
+      return grammar.rules[symbol.index].name;
   }
 
   string action_description(const ParseAction &action) const {
diff --git a/src/compiler/build_tables/build_tables.cc b/src/compiler/build_tables/build_tables.cc
index c8fba813..cbb1220e 100644
--- a/src/compiler/build_tables/build_tables.cc
+++ b/src/compiler/build_tables/build_tables.cc
@@ -1,7 +1,6 @@
 #include "compiler/build_tables/build_lex_table.h"
 #include "compiler/build_tables/build_parse_table.h"
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 namespace tree_sitter {
 namespace build_tables {
diff --git a/src/compiler/build_tables/first_symbols.cc b/src/compiler/build_tables/first_symbols.cc
index ffb8555e..33579e2f 100644
--- a/src/compiler/build_tables/first_symbols.cc
+++ b/src/compiler/build_tables/first_symbols.cc
@@ -1,6 +1,6 @@
 #include "compiler/build_tables/first_symbols.h"
 #include "compiler/build_tables/rule_can_be_blank.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/choice.h"
 #include "compiler/rules/metadata.h"
 #include "compiler/rules/seq.h"
@@ -28,8 +28,8 @@ class FirstSymbols : public rules::RuleFn<set<Symbol>> {
       return set<Symbol>();
 
     set<Symbol> result({ *rule });
-    if (!rule->is_token()) {
-      set<Symbol> &&symbols = apply(grammar->rule(*rule));
+    if (!rule->is_token) {
+      set<Symbol> &&symbols = apply(grammar->rules[rule->index].rule);
       result.insert(symbols.begin(), symbols.end());
     }
 
diff --git a/src/compiler/build_tables/item_set_closure.cc b/src/compiler/build_tables/item_set_closure.cc
index d586362f..e9148d7d 100644
--- a/src/compiler/build_tables/item_set_closure.cc
+++ b/src/compiler/build_tables/item_set_closure.cc
@@ -7,7 +7,7 @@
 #include "compiler/build_tables/rule_transitions.h"
 #include "compiler/build_tables/rule_can_be_blank.h"
 #include "compiler/build_tables/item.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 namespace tree_sitter {
 namespace build_tables {
@@ -41,7 +41,7 @@ const ParseItemSet item_set_closure(const ParseItem &starting_item,
       const Symbol &symbol = pair.first;
       const rule_ptr &next_rule = pair.second;
 
-      if (symbol.is_token() || symbol.is_built_in())
+      if (symbol.is_token || symbol.is_built_in())
         continue;
 
       set<Symbol> next_lookahead_symbols = first_symbols(next_rule, grammar);
@@ -49,8 +49,9 @@ const ParseItemSet item_set_closure(const ParseItem &starting_item,
         next_lookahead_symbols.insert(lookahead_symbols.begin(),
                                       lookahead_symbols.end());
 
-      items_to_process.push_back({ ParseItem(symbol, grammar.rule(symbol), {}),
-                                   next_lookahead_symbols });
+      items_to_process.push_back(
+        { ParseItem(symbol, grammar.rules[symbol.index].rule, {}),
+          next_lookahead_symbols });
     }
   }
 
diff --git a/src/compiler/build_tables/item_set_transitions.cc b/src/compiler/build_tables/item_set_transitions.cc
index 3cf4c83a..5fabc4c6 100644
--- a/src/compiler/build_tables/item_set_transitions.cc
+++ b/src/compiler/build_tables/item_set_transitions.cc
@@ -4,7 +4,7 @@
 #include "compiler/build_tables/merge_transitions.h"
 #include "compiler/build_tables/parse_item.h"
 #include "compiler/build_tables/rule_transitions.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/symbol.h"
 
 namespace tree_sitter {
diff --git a/src/compiler/build_tables/lex_conflict_manager.h b/src/compiler/build_tables/lex_conflict_manager.h
index cb26b896..6f35c967 100644
--- a/src/compiler/build_tables/lex_conflict_manager.h
+++ b/src/compiler/build_tables/lex_conflict_manager.h
@@ -2,7 +2,7 @@
 #define COMPILER_BUILD_TABLES_LEX_CONFLICT_MANAGER_H_
 
 #include "tree_sitter/compiler.h"
-#include "compiler/lexical_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 namespace tree_sitter {
 
diff --git a/src/compiler/build_tables/parse_conflict_manager.h b/src/compiler/build_tables/parse_conflict_manager.h
index 40557020..04f7e01c 100644
--- a/src/compiler/build_tables/parse_conflict_manager.h
+++ b/src/compiler/build_tables/parse_conflict_manager.h
@@ -3,8 +3,7 @@
 
 #include <utility>
 #include "tree_sitter/compiler.h"
-#include "compiler/syntax_grammar.h"
-#include "compiler/lexical_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/build_tables/parse_item.h"
 
 namespace tree_sitter {
diff --git a/src/compiler/build_tables/rule_can_be_blank.cc b/src/compiler/build_tables/rule_can_be_blank.cc
index 3e1276af..b378e68f 100644
--- a/src/compiler/build_tables/rule_can_be_blank.cc
+++ b/src/compiler/build_tables/rule_can_be_blank.cc
@@ -1,7 +1,7 @@
 #include "compiler/build_tables/rule_can_be_blank.h"
 #include <set>
 #include "tree_sitter/compiler.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/symbol.h"
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/seq.h"
@@ -55,7 +55,7 @@ class CanBeBlankRecursive : public CanBeBlank {
   bool apply_to(const rules::Symbol *rule) {
     if (visited_symbols.find(*rule) == visited_symbols.end()) {
       visited_symbols.insert(*rule);
-      return !rule->is_token() && apply(grammar->rule(*rule));
+      return !rule->is_token && apply(grammar->rules[rule->index].rule);
     } else {
       return false;
     }
diff --git a/src/compiler/compile.cc b/src/compiler/compile.cc
index 9f194e78..a5763f36 100644
--- a/src/compiler/compile.cc
+++ b/src/compiler/compile.cc
@@ -2,8 +2,7 @@
 #include "compiler/prepare_grammar/prepare_grammar.h"
 #include "compiler/build_tables/build_tables.h"
 #include "compiler/generate_code/c_code.h"
-#include "compiler/syntax_grammar.h"
-#include "compiler/lexical_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 namespace tree_sitter {
 
diff --git a/src/compiler/generate_code/c_code.cc b/src/compiler/generate_code/c_code.cc
index 25631ecc..bf3ca570 100644
--- a/src/compiler/generate_code/c_code.cc
+++ b/src/compiler/generate_code/c_code.cc
@@ -7,8 +7,7 @@
 #include "compiler/generate_code/c_code.h"
 #include "compiler/lex_table.h"
 #include "compiler/parse_table.h"
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/built_in_symbols.h"
 #include "compiler/util/string_helpers.h"
 
@@ -142,7 +141,7 @@ class CCodeGenerator {
     indent([&]() {
       for (const auto &symbol : parse_table.symbols)
         if (!symbol.is_built_in() &&
-            (symbol.is_auxiliary() || rule_name(symbol)[0] == '_'))
+            (is_auxiliary(symbol) || rule_name(symbol)[0] == '_'))
           line("[" + symbol_id(symbol) + "] = 1,");
     });
     line("};");
@@ -329,7 +328,7 @@ class CCodeGenerator {
         return "";
     } else {
       string name = sanitize_name(rule_name(symbol));
-      if (symbol.is_auxiliary())
+      if (is_auxiliary(symbol))
         return "aux_sym_" + name;
       else
         return "sym_" + name;
@@ -349,9 +348,20 @@ class CCodeGenerator {
     }
   }
 
+  bool is_auxiliary(const rules::Symbol &symbol) {
+    if (symbol.is_token) {
+      return lexical_grammar.rules[symbol.index].type != RuleEntryTypeNamed;
+    } else {
+      return syntax_grammar.rules[symbol.index].type != RuleEntryTypeNamed;
+    }
+  }
+
   string rule_name(const rules::Symbol &symbol) {
-    return symbol.is_token() ? lexical_grammar.rule_name(symbol)
-                             : syntax_grammar.rule_name(symbol);
+    if (symbol.is_token) {
+      return lexical_grammar.rules[symbol.index].name;
+    } else {
+      return syntax_grammar.rules[symbol.index].name;
+    }
   }
 
   bool reduce_action_is_fragile(const ParseAction &action) const {
@@ -394,15 +404,14 @@ class CCodeGenerator {
       if (('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') ||
           ('0' <= c && c <= '9') || (c == '_')) {
         stripped_name += c;
-        continue;
-      }
-
-      auto replacement = REPLACEMENTS.find(c);
-      if (replacement != REPLACEMENTS.end()) {
-        if (stripped_name[stripped_name.size() - 1] != '_')
-          stripped_name += "_";
-        stripped_name += replacement->second;
-        continue;
+      } else {
+        auto replacement = REPLACEMENTS.find(c);
+        size_t i = stripped_name.size();
+        if (replacement != REPLACEMENTS.end()) {
+          if (i > 0 && stripped_name[i - 1] != '_')
+            stripped_name += "_";
+          stripped_name += replacement->second;
+        }
       }
     }
 
diff --git a/src/compiler/lexical_grammar.cc b/src/compiler/lexical_grammar.cc
deleted file mode 100644
index 65fa9483..00000000
--- a/src/compiler/lexical_grammar.cc
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "compiler/lexical_grammar.h"
-#include <vector>
-#include <string>
-#include <utility>
-#include "compiler/rules/symbol.h"
-
-namespace tree_sitter {
-
-using std::string;
-using std::pair;
-using std::vector;
-using std::set;
-
-const rule_ptr &LexicalGrammar::rule(const rules::Symbol &symbol) const {
-  return symbol.is_auxiliary() ? aux_rules[symbol.index].second
-                               : rules[symbol.index].second;
-}
-
-const string &LexicalGrammar::rule_name(const rules::Symbol &symbol) const {
-  return symbol.is_auxiliary() ? aux_rules[symbol.index].first
-                               : rules[symbol.index].first;
-}
-
-}  // namespace tree_sitter
diff --git a/src/compiler/lexical_grammar.h b/src/compiler/lexical_grammar.h
deleted file mode 100644
index bd11d41e..00000000
--- a/src/compiler/lexical_grammar.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#ifndef COMPILER_LEXICAL_GRAMMAR_H_
-#define COMPILER_LEXICAL_GRAMMAR_H_
-
-#include <vector>
-#include <string>
-#include <utility>
-#include "tree_sitter/compiler.h"
-#include "compiler/rules/symbol.h"
-
-namespace tree_sitter {
-
-class LexicalGrammar {
- public:
-  const std::string &rule_name(const rules::Symbol &symbol) const;
-  const rule_ptr &rule(const rules::Symbol &symbol) const;
-
-  std::vector<std::pair<std::string, rule_ptr>> rules;
-  std::vector<std::pair<std::string, rule_ptr>> aux_rules;
-  std::vector<rule_ptr> separators;
-};
-
-}  // namespace tree_sitter
-
-#endif  // COMPILER_LEXICAL_GRAMMAR_H_
diff --git a/src/compiler/prepare_grammar/expand_repeats.cc b/src/compiler/prepare_grammar/expand_repeats.cc
index a08cf1a0..637fbe24 100644
--- a/src/compiler/prepare_grammar/expand_repeats.cc
+++ b/src/compiler/prepare_grammar/expand_repeats.cc
@@ -2,7 +2,7 @@
 #include <vector>
 #include <string>
 #include <utility>
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/seq.h"
 #include "compiler/rules/symbol.h"
@@ -40,12 +40,14 @@ class ExpandRepeats : public rules::IdentityRuleFn {
     size_t index = aux_rules.size();
     string helper_rule_name =
       rule_name + string("_repeat") + to_string(++repeat_count);
-    Symbol repeat_symbol(offset + index, rules::SymbolOptionAuxiliary);
+    Symbol repeat_symbol(offset + index);
     existing_repeats.push_back({ rule->copy(), repeat_symbol });
-    aux_rules.push_back(
-      { helper_rule_name,
-        Seq::build({ inner_rule, Choice::build({ repeat_symbol.copy(),
-                                                 make_shared<Blank>() }) }) });
+    aux_rules.push_back({
+      helper_rule_name,
+      Seq::build({ inner_rule, Choice::build({ repeat_symbol.copy(),
+                                               make_shared<Blank>() }) }),
+      RuleEntryTypeHidden,
+    });
     return repeat_symbol.copy();
   }
 
@@ -62,22 +64,21 @@ class ExpandRepeats : public rules::IdentityRuleFn {
     return apply(rule);
   }
 
-  vector<pair<string, rule_ptr>> aux_rules;
+  vector<RuleEntry> aux_rules;
 };
 
 SyntaxGrammar expand_repeats(const SyntaxGrammar &grammar) {
   SyntaxGrammar result;
-  result.aux_rules = grammar.aux_rules;
+  result.rules = grammar.rules;
   result.ubiquitous_tokens = grammar.ubiquitous_tokens;
   result.expected_conflicts = grammar.expected_conflicts;
 
-  ExpandRepeats expander(result.aux_rules.size());
-  for (auto &pair : grammar.rules)
-    result.rules.push_back(
-      { pair.first, expander.expand(pair.second, pair.first) });
+  ExpandRepeats expander(result.rules.size());
+  for (auto &rule_entry : result.rules)
+    rule_entry.rule = expander.expand(rule_entry.rule, rule_entry.name);
 
-  result.aux_rules.insert(result.aux_rules.end(), expander.aux_rules.begin(),
-                          expander.aux_rules.end());
+  result.rules.insert(result.rules.end(), expander.aux_rules.begin(),
+                      expander.aux_rules.end());
   return result;
 }
 
diff --git a/src/compiler/prepare_grammar/expand_tokens.cc b/src/compiler/prepare_grammar/expand_tokens.cc
index aaeb13ca..88251d8a 100644
--- a/src/compiler/prepare_grammar/expand_tokens.cc
+++ b/src/compiler/prepare_grammar/expand_tokens.cc
@@ -2,12 +2,14 @@
 #include <vector>
 #include <string>
 #include <utility>
-#include "compiler/lexical_grammar.h"
+#include <map>
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/pattern.h"
 #include "compiler/rules/string.h"
 #include "compiler/rules/blank.h"
 #include "compiler/rules/seq.h"
+#include "compiler/rules/metadata.h"
 #include "compiler/rules/character_set.h"
 #include "compiler/prepare_grammar/parse_regex.h"
 #include "utf8proc.h"
@@ -17,10 +19,12 @@ namespace prepare_grammar {
 
 using std::string;
 using std::vector;
+using std::map;
 using std::pair;
 using std::make_shared;
 using rules::String;
 using rules::Pattern;
+using rules::Metadata;
 
 class ExpandTokens : public rules::IdentityRuleFn {
   using rules::IdentityRuleFn::apply_to;
@@ -40,7 +44,11 @@ class ExpandTokens : public rules::IdentityRuleFn {
       elements.push_back(rules::CharacterSet().include(el).copy());
     }
 
-    return rules::Seq::build(elements);
+    return make_shared<rules::Metadata>(
+      rules::Seq::build(elements),
+      std::map<rules::MetadataKey, int>({
+        { rules::IS_TOKEN, 1 }, { rules::PRECEDENCE, 1 },
+      }));
   }
 
   rule_ptr apply_to(const Pattern *rule) {
@@ -60,18 +68,11 @@ pair<LexicalGrammar, const GrammarError *> expand_tokens(
   LexicalGrammar result;
   ExpandTokens expander;
 
-  for (auto &pair : grammar.rules) {
-    auto rule = expander.apply(pair.second);
+  for (auto &entry : grammar.rules) {
+    auto rule = expander.apply(entry.rule);
     if (expander.error)
       return { result, expander.error };
-    result.rules.push_back({ pair.first, rule });
-  }
-
-  for (auto &pair : grammar.aux_rules) {
-    auto rule = expander.apply(pair.second);
-    if (expander.error)
-      return { result, expander.error };
-    result.aux_rules.push_back({ pair.first, rule });
+    result.rules.push_back({ entry.name, rule, entry.type });
   }
 
   for (auto &sep : grammar.separators) {
@@ -81,9 +82,7 @@ pair<LexicalGrammar, const GrammarError *> expand_tokens(
     result.separators.push_back(rule);
   }
 
-  return {
-    result, nullptr,
-  };
+  return { result, nullptr };
 }
 
 }  // namespace prepare_grammar
diff --git a/src/compiler/prepare_grammar/extract_tokens.cc b/src/compiler/prepare_grammar/extract_tokens.cc
index cfefea64..88f0fc5b 100644
--- a/src/compiler/prepare_grammar/extract_tokens.cc
+++ b/src/compiler/prepare_grammar/extract_tokens.cc
@@ -4,8 +4,7 @@
 #include <set>
 #include <string>
 #include "tree_sitter/compiler.h"
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 #include "compiler/rules/visitor.h"
 #include "compiler/rules/symbol.h"
 #include "compiler/rules/string.h"
@@ -21,27 +20,15 @@ using std::dynamic_pointer_cast;
 using std::make_shared;
 using std::make_tuple;
 using std::map;
-using std::pair;
 using std::set;
 using std::string;
 using std::tuple;
 using std::vector;
 using rules::Symbol;
-using rules::SymbolOptionToken;
-using rules::SymbolOptionAuxToken;
 
 class SymbolReplacer : public rules::IdentityRuleFn {
   using rules::IdentityRuleFn::apply_to;
 
-  int new_index_for_symbol(const Symbol &symbol) {
-    int result = symbol.index;
-    for (const auto &pair : replacements)
-      if (pair.first.index < symbol.index &&
-          pair.first.is_auxiliary() == symbol.is_auxiliary())
-        result--;
-    return result;
-  }
-
   rule_ptr apply_to(const Symbol *rule) {
     return replace_symbol(*rule).copy();
   }
@@ -49,54 +36,64 @@ class SymbolReplacer : public rules::IdentityRuleFn {
  public:
   map<Symbol, Symbol> replacements;
 
-  Symbol replace_symbol(const Symbol &rule) {
-    if (rule.is_built_in())
-      return rule;
-    auto replacement_pair = replacements.find(rule);
+  Symbol replace_symbol(const Symbol &symbol) {
+    if (symbol.is_built_in() || symbol.is_token)
+      return symbol;
+
+    auto replacement_pair = replacements.find(symbol);
     if (replacement_pair != replacements.end())
       return replacement_pair->second;
-    else
-      return Symbol(new_index_for_symbol(rule), rule.options);
+
+    int new_index = symbol.index;
+    for (const auto &pair : replacements)
+      if (pair.first.index < symbol.index)
+        new_index--;
+    return Symbol(new_index);
   }
 };
 
 class TokenExtractor : public rules::IdentityRuleFn {
-  rule_ptr apply_to_token(const Rule *input) {
-    auto rule = input->copy();
+  using rules::IdentityRuleFn::apply_to;
+
+  rule_ptr apply_to_token(const Rule *input, RuleEntryType entry_type) {
     for (size_t i = 0; i < tokens.size(); i++)
-      if (tokens[i].second->operator==(*rule)) {
+      if (tokens[i].rule->operator==(*input)) {
         token_usage_counts[i]++;
-        return make_shared<Symbol>(i, SymbolOptionAuxToken);
+        return make_shared<Symbol>(i, true);
       }
+
+    rule_ptr rule = input->copy();
     size_t index = tokens.size();
-    tokens.push_back({ token_description(rule), rule });
+    tokens.push_back({
+      token_description(rule), rule, entry_type,
+    });
     token_usage_counts.push_back(1);
-    return make_shared<Symbol>(index, SymbolOptionAuxToken);
+    return make_shared<Symbol>(index, true);
   }
 
-  rule_ptr default_apply(const Rule *rule) {
-    auto result = rule->copy();
-    if (is_token(result))
-      return apply_to_token(rule);
-    else
-      return result;
+  rule_ptr apply_to(const rules::String *rule) {
+    return apply_to_token(rule, RuleEntryTypeAnonymous);
+  }
+
+  rule_ptr apply_to(const rules::Pattern *rule) {
+    return apply_to_token(rule, RuleEntryTypeHidden);
   }
 
   rule_ptr apply_to(const rules::Metadata *rule) {
-    if (is_token(rule->copy()))
-      return apply_to_token(rule);
+    if (rule->value_for(rules::IS_TOKEN) > 0)
+      return apply_to_token(rule->rule.get(), RuleEntryTypeHidden);
     else
       return rules::IdentityRuleFn::apply_to(rule);
   }
 
  public:
   vector<size_t> token_usage_counts;
-  vector<pair<string, rule_ptr>> tokens;
+  vector<RuleEntry> tokens;
 };
 
-static const GrammarError *ubiq_token_err(const string &msg) {
+static const GrammarError *ubiq_token_err(const string &message) {
   return new GrammarError(GrammarErrorTypeInvalidUbiquitousToken,
-                          "Not a token: " + msg);
+                          "Not a token: " + message);
 }
 
 tuple<SyntaxGrammar, LexicalGrammar, const GrammarError *> extract_tokens(
@@ -106,51 +103,43 @@ tuple<SyntaxGrammar, LexicalGrammar, const GrammarError *> extract_tokens(
   SymbolReplacer symbol_replacer;
   TokenExtractor extractor;
 
-  vector<pair<string, rule_ptr>> extracted_rules;
-  for (auto &pair : grammar.rules)
-    extracted_rules.push_back({ pair.first, extractor.apply(pair.second) });
+  /*
+   *  First, extract all of the grammar's tokens into the lexical grammar.
+   */
+  vector<RuleEntry> processed_rules;
+  for (const auto &pair : grammar.rules)
+    processed_rules.push_back({
+      pair.first, extractor.apply(pair.second), RuleEntryTypeNamed,
+    });
+  lexical_grammar.rules = extractor.tokens;
 
+  /*
+   *  If a rule's entire content was extracted as a token and that token didn't
+   *  appear within any other rule, then remove that rule from the syntax
+   *  grammar, giving its name to the token in the lexical grammar. Any symbols
+   *  that pointed to that rule will need to be updated to point to the rule in
+   *  the lexical grammar. Symbols that pointed to later rules will need to have
+   *  their indices decremented.
+   */
   size_t i = 0;
-  for (auto &pair : extracted_rules) {
-    auto &rule = pair.second;
-    auto symbol = dynamic_pointer_cast<const Symbol>(rule);
-    if (symbol.get() && symbol->is_auxiliary() &&
+  for (const RuleEntry &entry : processed_rules) {
+    auto symbol = dynamic_pointer_cast<const Symbol>(entry.rule);
+    if (symbol.get() && symbol->is_token && !symbol->is_built_in() &&
         extractor.token_usage_counts[symbol->index] == 1) {
-      lexical_grammar.rules.push_back(
-        { pair.first, extractor.tokens[symbol->index].second });
-      extractor.token_usage_counts[symbol->index] = 0;
-      symbol_replacer.replacements.insert(
-        { Symbol(i),
-          Symbol(lexical_grammar.rules.size() - 1, SymbolOptionToken) });
+      lexical_grammar.rules[symbol->index].type = entry.type;
+      lexical_grammar.rules[symbol->index].name = entry.name;
+      symbol_replacer.replacements.insert({ Symbol(i), *symbol });
     } else {
-      syntax_grammar.rules.push_back(pair);
+      syntax_grammar.rules.push_back(entry);
     }
     i++;
   }
 
-  for (auto &pair : syntax_grammar.rules)
-    pair.second = symbol_replacer.apply(pair.second);
-
-  lexical_grammar.aux_rules = extractor.tokens;
-
-  for (auto &rule : grammar.ubiquitous_tokens) {
-    if (is_token(rule)) {
-      lexical_grammar.separators.push_back(rule);
-    } else {
-      auto sym = dynamic_pointer_cast<const Symbol>(extractor.apply(rule));
-      if (!sym.get())
-        return make_tuple(syntax_grammar, lexical_grammar,
-                          ubiq_token_err(rule->to_string()));
-
-      Symbol symbol = symbol_replacer.replace_symbol(*sym);
-      if (!symbol.is_token())
-        return make_tuple(
-          syntax_grammar, lexical_grammar,
-          ubiq_token_err(syntax_grammar.rules[symbol.index].first));
-
-      syntax_grammar.ubiquitous_tokens.insert(symbol);
-    }
-  }
+  /*
+   *  Perform any replacements of symbols needed based on the previous step.
+   */
+  for (RuleEntry &entry : syntax_grammar.rules)
+    entry.rule = symbol_replacer.apply(entry.rule);
 
   for (auto &symbol_set : grammar.expected_conflicts) {
     set<Symbol> new_symbol_set;
@@ -159,6 +148,33 @@ tuple<SyntaxGrammar, LexicalGrammar, const GrammarError *> extract_tokens(
     syntax_grammar.expected_conflicts.insert(new_symbol_set);
   }
 
+  /*
+   *  The grammar's ubiquitous tokens can be either token rules or symbols
+   *  pointing to token rules. If they are symbols, then they'll be handled by
+   *  the parser; add them to the syntax grammar's ubiqutous tokens. If they
+   *  are anonymous rules, they can be handled by the lexer; add them to the
+   *  lexical grammar's separator rules.
+   */
+  for (const rule_ptr &rule : grammar.ubiquitous_tokens) {
+    if (is_token(rule)) {
+      lexical_grammar.separators.push_back(rule);
+      continue;
+    }
+
+    auto symbol = dynamic_pointer_cast<const Symbol>(rule);
+    if (!symbol.get())
+      return make_tuple(syntax_grammar, lexical_grammar,
+                        ubiq_token_err(rule->to_string()));
+
+    Symbol new_symbol = symbol_replacer.replace_symbol(*symbol);
+    if (!new_symbol.is_token)
+      return make_tuple(
+        syntax_grammar, lexical_grammar,
+        ubiq_token_err(syntax_grammar.rules[new_symbol.index].name));
+
+    syntax_grammar.ubiquitous_tokens.insert(new_symbol);
+  }
+
   return make_tuple(syntax_grammar, lexical_grammar, nullptr);
 }
 
diff --git a/src/compiler/prepare_grammar/prepare_grammar.cc b/src/compiler/prepare_grammar/prepare_grammar.cc
index 42d60e91..e4b1d77d 100644
--- a/src/compiler/prepare_grammar/prepare_grammar.cc
+++ b/src/compiler/prepare_grammar/prepare_grammar.cc
@@ -3,8 +3,7 @@
 #include "compiler/prepare_grammar/extract_tokens.h"
 #include "compiler/prepare_grammar/intern_symbols.h"
 #include "compiler/prepare_grammar/prepare_grammar.h"
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 namespace tree_sitter {
 namespace prepare_grammar {
diff --git a/src/compiler/prepare_grammar/prepare_grammar.h b/src/compiler/prepare_grammar/prepare_grammar.h
index 80196c8b..471a4420 100644
--- a/src/compiler/prepare_grammar/prepare_grammar.h
+++ b/src/compiler/prepare_grammar/prepare_grammar.h
@@ -2,8 +2,7 @@
 #define COMPILER_PREPARE_GRAMMAR_PREPARE_GRAMMAR_H_
 
 #include <utility>
-#include "compiler/lexical_grammar.h"
-#include "compiler/syntax_grammar.h"
+#include "compiler/prepared_grammar.h"
 
 namespace tree_sitter {
 
diff --git a/src/compiler/prepare_grammar/token_description.cc b/src/compiler/prepare_grammar/token_description.cc
index d0294546..9d5bde58 100644
--- a/src/compiler/prepare_grammar/token_description.cc
+++ b/src/compiler/prepare_grammar/token_description.cc
@@ -5,6 +5,7 @@
 #include "compiler/rules/seq.h"
 #include "compiler/rules/choice.h"
 #include "compiler/rules/string.h"
+#include "compiler/rules/repeat.h"
 #include "compiler/rules/metadata.h"
 #include "compiler/util/string_helpers.h"
 
@@ -15,11 +16,12 @@ using std::string;
 
 class TokenDescription : public rules::RuleFn<string> {
   string apply_to(const rules::Pattern *rule) {
-    return "PAT_" + util::escape_string(rule->value);
+    is_trivial = false;
+    return rule->value;
   }
 
   string apply_to(const rules::String *rule) {
-    return "STR_" + util::escape_string(rule->value);
+    return rule->value;
   }
 
   string apply_to(const rules::Metadata *rule) {
@@ -27,19 +29,41 @@ class TokenDescription : public rules::RuleFn<string> {
   }
 
   string apply_to(const rules::Seq *rule) {
-    return "(seq " + apply(rule->left) + " " + apply(rule->right) + ")";
+    is_trivial = false;
+    return apply(rule->left) + apply(rule->right);
+  }
+
+  string apply_to(const rules::Repeat *rule) {
+    is_trivial = false;
+    return apply(rule->content) + "*";
   }
 
   string apply_to(const rules::Choice *rule) {
-    string result = "(choice";
-    for (auto &element : rule->elements)
-      result += " " + apply(element);
+    is_trivial = false;
+    string result = "(";
+    bool started = false;
+    for (auto &element : rule->elements) {
+      if (started)
+        result += "|";
+      result += apply(element);
+      started = true;
+    }
     return result + ")";
   }
+
+ public:
+  bool is_trivial;
+
+  TokenDescription() : is_trivial(true) {}
 };
 
-std::string token_description(const rule_ptr &rule) {
-  return TokenDescription().apply(rule);
+string token_description(const rule_ptr &rule) {
+  TokenDescription description;
+  string result = description.apply(rule);
+  if (description.is_trivial)
+    return result;
+  else
+    return "/" + result + "/";
 }
 
 }  // namespace prepare_grammar
diff --git a/src/compiler/prepared_grammar.h b/src/compiler/prepared_grammar.h
new file mode 100644
index 00000000..be60321f
--- /dev/null
+++ b/src/compiler/prepared_grammar.h
@@ -0,0 +1,39 @@
+#ifndef COMPILER_PREPARED_GRAMMAR_H_
+#define COMPILER_PREPARED_GRAMMAR_H_
+
+#include <vector>
+#include <string>
+#include <set>
+#include "tree_sitter/compiler.h"
+#include "compiler/rules/symbol.h"
+
+namespace tree_sitter {
+
+enum RuleEntryType {
+  RuleEntryTypeNamed,
+  RuleEntryTypeAnonymous,
+  RuleEntryTypeHidden,
+};
+
+struct RuleEntry {
+  std::string name;
+  rule_ptr rule;
+  RuleEntryType type;
+};
+
+class SyntaxGrammar {
+ public:
+  std::vector<RuleEntry> rules;
+  std::set<rules::Symbol> ubiquitous_tokens;
+  std::set<std::set<rules::Symbol>> expected_conflicts;
+};
+
+class LexicalGrammar {
+ public:
+  std::vector<RuleEntry> rules;
+  std::vector<rule_ptr> separators;
+};
+
+}  // namespace tree_sitter
+
+#endif  // COMPILER_PREPARED_GRAMMAR_H_
diff --git a/src/compiler/rules/built_in_symbols.cc b/src/compiler/rules/built_in_symbols.cc
index 9d1e924b..c37e7e11 100644
--- a/src/compiler/rules/built_in_symbols.cc
+++ b/src/compiler/rules/built_in_symbols.cc
@@ -4,11 +4,11 @@ namespace tree_sitter {
 namespace rules {
 
 Symbol END_OF_INPUT() {
-  return Symbol(-1, SymbolOptionToken);
+  return Symbol(-1, true);
 }
 
 Symbol ERROR() {
-  return Symbol(-2, SymbolOptionToken);
+  return Symbol(-2, true);
 }
 
 Symbol START() {
diff --git a/src/compiler/rules/rules.cc b/src/compiler/rules/rules.cc
index 6484d8a2..5b87c5e5 100644
--- a/src/compiler/rules/rules.cc
+++ b/src/compiler/rules/rules.cc
@@ -52,7 +52,7 @@ rule_ptr pattern(const string &value) {
 }
 
 rule_ptr str(const string &value) {
-  return token(prec(1, make_shared<rules::String>(value)));
+  return make_shared<rules::String>(value);
 }
 
 rule_ptr err(const rule_ptr &rule) {
diff --git a/src/compiler/rules/symbol.cc b/src/compiler/rules/symbol.cc
index b9f213f2..33472874 100644
--- a/src/compiler/rules/symbol.cc
+++ b/src/compiler/rules/symbol.cc
@@ -10,16 +10,12 @@ using std::string;
 using std::to_string;
 using std::hash;
 
-SymbolOption SymbolOptionAuxToken =
-  SymbolOption(SymbolOptionToken | SymbolOptionAuxiliary);
+Symbol::Symbol(int index) : index(index), is_token(false) {}
 
-Symbol::Symbol(int index) : index(index), options(SymbolOption(0)) {}
-
-Symbol::Symbol(int index, SymbolOption options)
-    : index(index), options(options) {}
+Symbol::Symbol(int index, bool is_token) : index(index), is_token(is_token) {}
 
 bool Symbol::operator==(const Symbol &other) const {
-  return (other.index == index) && (other.options == options);
+  return (other.index == index) && (other.is_token == is_token);
 }
 
 bool Symbol::operator==(const Rule &rule) const {
@@ -28,7 +24,7 @@ bool Symbol::operator==(const Rule &rule) const {
 }
 
 size_t Symbol::hash_code() const {
-  return hash<int>()(index) ^ hash<int16_t>()(options);
+  return hash<int>()(index) ^ hash<bool>()(is_token);
 }
 
 rule_ptr Symbol::copy() const {
@@ -36,31 +32,22 @@ rule_ptr Symbol::copy() const {
 }
 
 string Symbol::to_string() const {
-  string name = (options & SymbolOptionAuxiliary) ? "aux_" : "";
-  name += (options & SymbolOptionToken) ? "token" : "sym";
+  string name = is_token ? "token" : "sym";
   return "(" + name + " " + std::to_string(index) + ")";
 }
 
 bool Symbol::operator<(const Symbol &other) const {
-  if (options < other.options)
+  if (!is_token && other.is_token)
     return true;
-  if (options > other.options)
+  if (is_token && !other.is_token)
     return false;
   return (index < other.index);
 }
 
-bool Symbol::is_token() const {
-  return options & SymbolOptionToken;
-}
-
 bool Symbol::is_built_in() const {
   return index < 0;
 }
 
-bool Symbol::is_auxiliary() const {
-  return options & SymbolOptionAuxiliary;
-}
-
 void Symbol::accept(Visitor *visitor) const {
   visitor->visit(this);
 }
diff --git a/src/compiler/rules/symbol.h b/src/compiler/rules/symbol.h
index a1c62b54..81d74d85 100644
--- a/src/compiler/rules/symbol.h
+++ b/src/compiler/rules/symbol.h
@@ -7,17 +7,10 @@
 namespace tree_sitter {
 namespace rules {
 
-typedef enum {
-  SymbolOptionToken = 1 << 0,
-  SymbolOptionAuxiliary = 1 << 1,
-} SymbolOption;
-
-extern SymbolOption SymbolOptionAuxToken;
-
 class Symbol : public Rule {
  public:
   explicit Symbol(int index);
-  Symbol(int index, SymbolOption options);
+  Symbol(int index, bool is_token);
 
   bool operator==(const Symbol &other) const;
   bool operator==(const Rule &other) const;
@@ -28,12 +21,10 @@ class Symbol : public Rule {
   void accept(Visitor *visitor) const;
 
   bool operator<(const Symbol &other) const;
-  bool is_token() const;
   bool is_built_in() const;
-  bool is_auxiliary() const;
 
   int index;
-  SymbolOption options;
+  bool is_token;
 };
 
 }  // namespace rules
diff --git a/src/compiler/syntax_grammar.cc b/src/compiler/syntax_grammar.cc
deleted file mode 100644
index 959a879f..00000000
--- a/src/compiler/syntax_grammar.cc
+++ /dev/null
@@ -1,21 +0,0 @@
-#include "compiler/syntax_grammar.h"
-#include <vector>
-#include <string>
-#include <utility>
-#include "compiler/rules/symbol.h"
-
-namespace tree_sitter {
-
-using std::string;
-
-const rule_ptr &SyntaxGrammar::rule(const rules::Symbol &symbol) const {
-  return symbol.is_auxiliary() ? aux_rules[symbol.index].second
-                               : rules[symbol.index].second;
-}
-
-const string &SyntaxGrammar::rule_name(const rules::Symbol &symbol) const {
-  return symbol.is_auxiliary() ? aux_rules[symbol.index].first
-                               : rules[symbol.index].first;
-}
-
-}  // namespace tree_sitter
diff --git a/src/compiler/syntax_grammar.h b/src/compiler/syntax_grammar.h
deleted file mode 100644
index ad636a1e..00000000
--- a/src/compiler/syntax_grammar.h
+++ /dev/null
@@ -1,26 +0,0 @@
-#ifndef COMPILER_SYNTAX_GRAMMAR_H_
-#define COMPILER_SYNTAX_GRAMMAR_H_
-
-#include <vector>
-#include <string>
-#include <set>
-#include <utility>
-#include "tree_sitter/compiler.h"
-#include "compiler/rules/symbol.h"
-
-namespace tree_sitter {
-
-class SyntaxGrammar {
- public:
-  const std::string &rule_name(const rules::Symbol &symbol) const;
-  const rule_ptr &rule(const rules::Symbol &symbol) const;
-
-  std::vector<std::pair<std::string, rule_ptr>> rules;
-  std::vector<std::pair<std::string, rule_ptr>> aux_rules;
-  std::set<rules::Symbol> ubiquitous_tokens;
-  std::set<std::set<rules::Symbol>> expected_conflicts;
-};
-
-}  // namespace tree_sitter
-
-#endif  // COMPILER_SYNTAX_GRAMMAR_H_